pool = connectionPool;
return pool == null ? 0 : pool.getNumIdle();
}
/**
* Gets the value of the {code numTestsPerEvictionRun} property.
*
* @return the number of objects to examine during idle object evictor runs
* @see #setNumTestsPerEvictionRun(int)
*/
@Override
public synchronized int getNumTestsPerEvictionRun() {
return this.numTestsPerEvictionRun;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new SQLFeatureNotSupportedException();
}
/**
* Gets the password passed to the JDBC driver to establish connections.
*
* @return the connection password
*/
@Override
public String getPassword() {
return this.password;
}
/**
* Gets the registered JMX ObjectName.
*
* @return the registered JMX ObjectName.
*/
protected ObjectName getRegisteredJmxName() {
return ObjectNameWrapper.unwrap(registeredJmxObjectName);
}
/**
* 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 {@link #getRemoveAbandonedTimeoutDuration() removeAbandonedTimeout} seconds.
*
*
* Abandoned connections are identified and removed when {@link #getConnection()} is invoked and all of the
* following conditions hold:
*
*
* - {@link #getRemoveAbandonedOnBorrow()}
* - {@link #getNumActive()} > {@link #getMaxTotal()} - 3
* - {@link #getNumIdle()} < 2
*
*
* @see #getRemoveAbandonedTimeoutDuration()
*/
@Override
public boolean getRemoveAbandonedOnBorrow() {
return abandonedConfig != null && abandonedConfig.getRemoveAbandonedOnBorrow();
}
/**
* 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 {@link #getRemoveAbandonedTimeoutDuration() removeAbandonedTimeout} seconds.
*
*
* @see #getRemoveAbandonedTimeoutDuration()
*/
@Override
public boolean getRemoveAbandonedOnMaintenance() {
return abandonedConfig != null && abandonedConfig.getRemoveAbandonedOnMaintenance();
}
/**
* Gets the 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:
*
*
* - {@link #getRemoveAbandonedOnBorrow()} or {@link #getRemoveAbandonedOnMaintenance()} = true
* - {@link #getNumIdle() numIdle} < 2
* - {@link #getNumActive() numActive} > {@link #getMaxTotal() maxTotal} - 3
*
*
* The default value is 300 seconds.
*
* @deprecated Use {@link #getRemoveAbandonedTimeoutDuration()}.
*/
@Deprecated
@Override
public int getRemoveAbandonedTimeout() {
return (int) getRemoveAbandonedTimeoutDuration().getSeconds();
}
/**
* Gets the timeout 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:
*
*
* - {@link #getRemoveAbandonedOnBorrow()} or {@link #getRemoveAbandonedOnMaintenance()} = true
* - {@link #getNumIdle() numIdle} < 2
* - {@link #getNumActive() numActive} > {@link #getMaxTotal() maxTotal} - 3
*
*
* The default value is 300 seconds.
*
* @return Timeout before an abandoned connection can be removed.
* @since 2.10.0
*/
public Duration getRemoveAbandonedTimeoutDuration() {
return abandonedConfig == null ? Duration.ofSeconds(300) : abandonedConfig.getRemoveAbandonedTimeoutDuration();
}
/**
* 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.
*
* @return whether a connection will be rolled back when it is returned to the pool.
*/
public boolean getRollbackOnReturn() {
return rollbackOnReturn;
}
/**
* Gets 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 {@link #getMinEvictableIdleTimeMillis() 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 {@code minEvictableIdleTimeMillis} (without
* considering the number of idle connections in the pool) and then against {@code softMinEvictableIdleTimeMillis},
* including the {@code minIdle}, constraint.
*
*
* @return 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
* @since 2.10.0
*/
public synchronized Duration getSoftMinEvictableIdleDuration() {
return softMinEvictableIdleDuration;
}
/**
* Gets 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 {@link #getMinEvictableIdleTimeMillis() 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 {@code minEvictableIdleTimeMillis} (without
* considering the number of idle connections in the pool) and then against {@code softMinEvictableIdleTimeMillis},
* including the {@code minIdle}, constraint.
*
*
* @return 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
* @deprecated Use {@link #getSoftMinEvictableIdleDuration()}.
*/
@Deprecated
@Override
public synchronized long getSoftMinEvictableIdleTimeMillis() {
return softMinEvictableIdleDuration.toMillis();
}
/**
* Gets the {code testOnBorrow} property.
*
* @return true if objects are validated before being borrowed from the pool
*
* @see #setTestOnBorrow(boolean)
*/
@Override
public synchronized boolean getTestOnBorrow() {
return this.testOnBorrow;
}
/**
* Gets the {code testOnCreate} property.
*
* @return true if objects are validated immediately after they are created by the pool
* @see #setTestOnCreate(boolean)
*/
@Override
public synchronized boolean getTestOnCreate() {
return this.testOnCreate;
}
/**
* Gets the value of the {code testOnReturn} property.
*
* @return true if objects are validated before being returned to the pool
* @see #setTestOnReturn(boolean)
*/
public synchronized boolean getTestOnReturn() {
return this.testOnReturn;
}
/**
* Gets the value of the {code testWhileIdle} property.
*
* @return true if objects examined by the idle object evictor are validated
* @see #setTestWhileIdle(boolean)
*/
@Override
public synchronized boolean getTestWhileIdle() {
return this.testWhileIdle;
}
/**
* Gets the value of the {code durationBetweenEvictionRuns} property.
*
* @return the time (in milliseconds) between evictor runs
* @see #setDurationBetweenEvictionRuns(Duration)
* @since 2.10.0
*/
public synchronized Duration getDurationBetweenEvictionRuns() {
return this.durationBetweenEvictionRuns;
}
/**
* Gets the value of the {code durationBetweenEvictionRuns} property.
*
* @return the time (in milliseconds) between evictor runs
* @see #setDurationBetweenEvictionRuns(Duration)
* @deprecated Use {@link #getDurationBetweenEvictionRuns()}.
*/
@Deprecated
@Override
public synchronized long getTimeBetweenEvictionRunsMillis() {
return this.durationBetweenEvictionRuns.toMillis();
}
/**
* Gets the JDBC connection {code connectionString} property.
*
* @return the {code connectionString} passed to the JDBC driver to establish connections
*/
@Override
public synchronized String getUrl() {
return this.connectionString;
}
/**
* Gets the JDBC connection {code userName} property.
*
* @return the {code userName} passed to the JDBC driver to establish connections
*/
@Override
public String getUsername() {
return this.userName;
}
/**
* Gets the validation query used to validate connections before returning them.
*
* @return the SQL validation query
* @see #setValidationQuery(String)
*/
@Override
public String getValidationQuery() {
return this.validationQuery;
}
/**
* Gets the validation query timeout.
*
* @return the timeout in seconds before connection validation queries fail.
*/
public Duration getValidationQueryTimeoutDuration() {
return validationQueryTimeoutDuration;
}
/**
* Gets the validation query timeout.
*
* @return the timeout in seconds before connection validation queries fail.
* @deprecated Use {@link #getValidationQueryTimeoutDuration()}.
*/
@Deprecated
@Override
public int getValidationQueryTimeout() {
return (int) validationQueryTimeoutDuration.getSeconds();
}
/**
* Manually invalidates a connection, effectively requesting the pool to try to close it, remove it from the pool
* and reclaim pool capacity.
*
* @param connection The Connection to invalidate.
*
* @throws IllegalStateException if invalidating the connection failed.
* @since 2.1
*/
@SuppressWarnings("resource")
public void invalidateConnection(final Connection connection) throws IllegalStateException {
if (connection == null) {
return;
}
if (connectionPool == null) {
throw new IllegalStateException("Cannot invalidate connection: ConnectionPool is null.");
}
final PoolableConnection poolableConnection;
try {
poolableConnection = connection.unwrap(PoolableConnection.class);
if (poolableConnection == null) {
throw new IllegalStateException(
"Cannot invalidate connection: Connection is not a poolable connection.");
}
} catch (final SQLException e) {
throw new IllegalStateException("Cannot invalidate connection: Unwrapping poolable connection failed.", e);
}
try {
connectionPool.invalidateObject(poolableConnection);
} catch (final Exception e) {
throw new IllegalStateException("Invalidating connection threw unexpected exception", e);
}
}
/**
* Gets the value of the accessToUnderlyingConnectionAllowed property.
*
* @return true if access to the underlying connection is allowed, false otherwise.
*/
@Override
public synchronized boolean isAccessToUnderlyingConnectionAllowed() {
return this.accessToUnderlyingConnectionAllowed;
}
/**
* Returns true if the statement pool is cleared when the connection is returned to its pool.
*
* @return true if the statement pool is cleared at connection return
* @since 2.8.0
*/
@Override
public boolean isClearStatementPoolOnReturn() {
return clearStatementPoolOnReturn;
}
/**
* If true, this data source is closed and no more connections can be retrieved from this data source.
*
* @return true, if the data source is closed; false otherwise
*/
@Override
public synchronized boolean isClosed() {
return closed;
}
/**
* Delegates in a null-safe manner to {@link String#isEmpty()}.
*
* @param value the string to test, may be null.
* @return boolean false if value is null, otherwise {@link String#isEmpty()}.
*/
private boolean isEmpty(final String value) {
return value == null || value.trim().isEmpty();
}
/**
* Returns true if we are pooling statements.
*
* @return true if prepared and callable statements are pooled
*/
@Override
public synchronized boolean isPoolPreparedStatements() {
return this.poolPreparedStatements;
}
@Override
public boolean isWrapperFor(final Class iface) throws SQLException {
return iface != null && iface.isInstance(this);
}
private void jmxRegister() {
// Return immediately if this DataSource has already been registered
if (registeredJmxObjectName != null) {
return;
}
// Return immediately if no JMX name has been specified
final String requestedName = getJmxName();
if (requestedName == null) {
return;
}
registeredJmxObjectName = registerJmxObjectName(requestedName, null);
try {
final StandardMBean standardMBean = new StandardMBean(this, DataSourceMXBean.class);
registeredJmxObjectName.registerMBean(standardMBean);
} catch (final NotCompliantMBeanException e) {
log.warn("The requested JMX name [" + requestedName + "] was not valid and will be ignored.");
}
}
/**
* Logs the given message.
*
* @param message the message to log.
*/
protected void log(final String message) {
if (logWriter != null) {
logWriter.println(message);
}
}
/**
* Logs the given throwable.
* @param message TODO
* @param throwable the throwable.
*
* @since 2.7.0
*/
protected void log(final String message, final Throwable throwable) {
if (logWriter != null) {
logWriter.println(message);
throwable.printStackTrace(logWriter);
}
}
@Override
public void postDeregister() {
// NO-OP
}
@Override
public void postRegister(final Boolean registrationDone) {
// NO-OP
}
@Override
public void preDeregister() throws Exception {
// NO-OP
}
@Override
public ObjectName preRegister(final MBeanServer server, final ObjectName objectName) {
registeredJmxObjectName = registerJmxObjectName(getJmxName(), objectName);
return ObjectNameWrapper.unwrap(registeredJmxObjectName);
}
private ObjectNameWrapper registerJmxObjectName(final String requestedName, final ObjectName objectName) {
ObjectNameWrapper objectNameWrapper = null;
if (requestedName != null) {
try {
objectNameWrapper = ObjectNameWrapper.wrap(requestedName);
} catch (final MalformedObjectNameException e) {
log.warn("The requested JMX name '" + requestedName + "' was not valid and will be ignored.");
}
}
if (objectNameWrapper == null) {
objectNameWrapper = ObjectNameWrapper.wrap(objectName);
}
return objectNameWrapper;
}
/**
* Removes a custom connection property.
*
* @param name Name of the custom connection property to remove
* @see #addConnectionProperty(String, String)
*/
public void removeConnectionProperty(final String name) {
connectionProperties.remove(name);
}
/**
* Restarts the datasource.
*
* This method calls {@link #close()} and {@link #start()} in sequence within synchronized scope so any
* connection requests that come in while the datasource is shutting down will be served by the new pool.
*
* Idle connections that are stored in the connection pool when this method is invoked are closed, but
* connections that are checked out to clients when this method is invoked are not affected. When client
* applications subsequently invoke {@link Connection#close()} to return these connections to the pool, the
* underlying JDBC connections are closed. These connections do not count in {@link #getMaxTotal()} or
* {@link #getNumActive()} after invoking this method. For example, if there are 3 connections checked out by
* clients when {@link #restart()} is invoked, after this method is called, {@link #getNumActive()} will
* return 0 and up to {@link #getMaxTotal()} + 3 connections may be open until the connections sourced from
* the original pool are returned.
*
* The new connection pool created by this method is initialized with currently set configuration properties.
*
* @throws SQLException if an error occurs initializing the datasource
*/
@Override
public synchronized void restart() throws SQLException {
close();
start();
}
private void setAbandoned(final BiConsumer consumer, final T object) {
if (abandonedConfig == null) {
abandonedConfig = new AbandonedConfig();
}
consumer.accept(abandonedConfig, object);
final GenericObjectPool gop = this.connectionPool;
if (gop != null) {
gop.setAbandonedConfig(abandonedConfig);
}
}
private void setConnectionPool(final BiConsumer, T> consumer, final T object) {
if (connectionPool != null) {
consumer.accept(connectionPool, object);
}
}
/**
* Sets the print writer to be used by this configuration to log information on abandoned objects.
*
* @param logWriter The new log writer
*/
public void setAbandonedLogWriter(final PrintWriter logWriter) {
setAbandoned(AbandonedConfig::setLogWriter, logWriter);
}
/**
* If the connection pool implements {@link org.apache.commons.pool2.UsageTracking 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.
*
* @param usageTracking A value of {@code true} will enable the recording of a stack trace on every use of a
* pooled connection
*/
public void setAbandonedUsageTracking(final boolean usageTracking) {
setAbandoned(AbandonedConfig::setUseUsageTracking, usageTracking);
}
/**
* 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.
*
*
* @param allow Access to the underlying connection is granted when true.
*/
public synchronized void setAccessToUnderlyingConnectionAllowed(final boolean allow) {
this.accessToUnderlyingConnectionAllowed = allow;
}
/**
* Sets the value of the flag that controls whether or not connections being returned to the pool will be checked
* and configured with {@link Connection#setAutoCommit(boolean) Connection.setAutoCommit(true)} if the auto commit
* setting is {@code false} when the connection is returned. It is {@code true} by default.
*
* @param autoCommitOnReturn Whether or not connections being returned to the pool will be checked and configured
* with auto-commit.
* @since 2.6.0
*/
public void setAutoCommitOnReturn(final boolean autoCommitOnReturn) {
this.autoCommitOnReturn = autoCommitOnReturn;
}
/**
* Sets the state caching flag.
*
* @param cacheState The new value for the state caching flag
*/
public void setCacheState(final boolean cacheState) {
this.cacheState = cacheState;
}
/**
* Sets whether the pool of statements (which was enabled with {@link #setPoolPreparedStatements(boolean)}) should
* be cleared when the connection is returned to its pool. Default is false.
*
* @param clearStatementPoolOnReturn clear or not
* @since 2.8.0
*/
public void setClearStatementPoolOnReturn(final boolean clearStatementPoolOnReturn) {
this.clearStatementPoolOnReturn = clearStatementPoolOnReturn;
}
/**
* Sets the ConnectionFactory class name.
*
* @param connectionFactoryClassName A class name.
* @since 2.7.0
*/
public void setConnectionFactoryClassName(final String connectionFactoryClassName) {
this.connectionFactoryClassName = isEmpty(connectionFactoryClassName) ? null : connectionFactoryClassName;
}
/**
* 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.
*
*
* @param connectionInitSqls Collection of SQL statements to execute on connection creation
*/
public void setConnectionInitSqls(final Collection connectionInitSqls) {
// if (connectionInitSqls != null && !connectionInitSqls.isEmpty()) {
// ArrayList newVal = null;
// for (final String s : connectionInitSqls) {
// if (!isEmpty(s)) {
// if (newVal == null) {
// newVal = new ArrayList<>();
// }
// newVal.add(s);
// }
// }
// this.connectionInitSqls = newVal;
// } else {
// this.connectionInitSqls = null;
// }
final List collect = Utils.isEmpty(connectionInitSqls) ? null
: connectionInitSqls.stream().filter(s -> !isEmpty(s)).collect(Collectors.toList());
this.connectionInitSqls = Utils.isEmpty(collect) ? null : collect;
}
/**
* 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.
*
*
* @param connectionProperties the connection properties used to create new connections
*/
public void setConnectionProperties(final String connectionProperties) {
Objects.requireNonNull(connectionProperties, "connectionProperties");
final String[] entries = connectionProperties.split(";");
final Properties properties = new Properties();
Stream.of(entries).filter(e -> !e.isEmpty()).forEach(entry -> {
final int index = entry.indexOf('=');
if (index > 0) {
final String name = entry.substring(0, index);
final String value = entry.substring(index + 1);
properties.setProperty(name, value);
} else {
// no value is empty string which is how
// java.util.Properties works
properties.setProperty(entry, "");
}
});
this.connectionProperties = properties;
}
/**
* 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.
*
*
* @param defaultAutoCommit default auto-commit value
*/
public void setDefaultAutoCommit(final Boolean defaultAutoCommit) {
this.defaultAutoCommit = defaultAutoCommit;
}
/**
* 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.
*
*
* @param defaultCatalog the default catalog
*/
public void setDefaultCatalog(final String defaultCatalog) {
this.defaultCatalog = isEmpty(defaultCatalog) ? null : defaultCatalog;
}
/**
* Sets the default query timeout that will be used for {@link java.sql.Statement Statement}s created from this
* connection. {@code null} means that the driver default will be used.
*
* @param defaultQueryTimeoutDuration The default query timeout Duration.
* @since 2.10.0
*/
public void setDefaultQueryTimeout(final Duration defaultQueryTimeoutDuration) {
this.defaultQueryTimeoutDuration = defaultQueryTimeoutDuration;
}
/**
* Sets the default query timeout that will be used for {@link java.sql.Statement Statement}s created from this
* connection. {@code null} means that the driver default will be used.
*
* @param defaultQueryTimeoutSeconds The default query timeout in seconds.
* @deprecated Use {@link #setDefaultQueryTimeout(Duration)}.
*/
@Deprecated
public void setDefaultQueryTimeout(final Integer defaultQueryTimeoutSeconds) {
this.defaultQueryTimeoutDuration = defaultQueryTimeoutSeconds == null ? null : Duration.ofSeconds(defaultQueryTimeoutSeconds);
}
/**
* 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.
*
*
* @param defaultReadOnly default read-only value
*/
public void setDefaultReadOnly(final Boolean defaultReadOnly) {
this.defaultReadOnly = defaultReadOnly;
}
/**
* 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.
*
*
* @param defaultSchema the default catalog
* @since 2.5.0
*/
public void setDefaultSchema(final String defaultSchema) {
this.defaultSchema = isEmpty(defaultSchema) ? null : defaultSchema;
}
/**
* 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.
*
*
* @param defaultTransactionIsolation the default transaction isolation state
* @see Connection#getTransactionIsolation
*/
public void setDefaultTransactionIsolation(final int defaultTransactionIsolation) {
this.defaultTransactionIsolation = defaultTransactionIsolation;
}
/**
* Sets the SQL_STATE codes considered to signal fatal conditions.
*
* Overrides the defaults in {@link Utils#getDisconnectionSqlCodes()} (plus anything starting with
* {@link Utils#DISCONNECTION_SQL_CODE_PREFIX}). If this property is non-null and {@link #getFastFailValidation()}
* is {@code 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 {@link #getFastFailValidation()} is {@code 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: {@code getConnection, setLogwriter,
* setLoginTimeout, getLoginTimeout, getLogWriter}.
*
*
* @param disconnectionSqlCodes SQL_STATE codes considered to signal fatal conditions
* @since 2.1
*/
public void setDisconnectionSqlCodes(final Collection disconnectionSqlCodes) {
// if (disconnectionSqlCodes != null && !disconnectionSqlCodes.isEmpty()) {
// HashSet newVal = null;
// for (final String s : disconnectionSqlCodes) {
// if (!isEmpty(s)) {
// if (newVal == null) {
// newVal = new HashSet<>();
// }
// newVal.add(s);
// }
// }
// this.disconnectionSqlCodes = newVal;
// } else {
// this.disconnectionSqlCodes = null;
// }
final Set collect = Utils.isEmpty(disconnectionSqlCodes) ? null
: disconnectionSqlCodes.stream().filter(s -> !isEmpty(s)).collect(Collectors.toSet());
this.disconnectionSqlCodes = Utils.isEmpty(collect) ? null : collect;
}
/**
* 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.
*
*
* @param driver The JDBC Driver instance to use for this pool.
*/
public synchronized void setDriver(final Driver driver) {
this.driver = driver;
}
/**
* 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.
*
*
* @param driverClassLoader the class loader with which to load the JDBC driver
*/
public synchronized void setDriverClassLoader(final ClassLoader driverClassLoader) {
this.driverClassLoader = driverClassLoader;
}
/**
* 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.
*
*
* @param driverClassName the class name of the JDBC driver
*/
public synchronized void setDriverClassName(final String driverClassName) {
this.driverClassName = isEmpty(driverClassName) ? null : driverClassName;
}
/**
* Sets the value of the flag that controls whether or not connections being returned to the pool will be checked
* and configured with {@link Connection#setAutoCommit(boolean) Connection.setAutoCommit(true)} if the auto commit
* setting is {@code false} when the connection is returned. It is {@code true} by default.
*
* @param autoCommitOnReturn Whether or not connections being returned to the pool will be checked and configured
* with auto-commit.
* @deprecated Use {@link #setAutoCommitOnReturn(boolean)}.
*/
@Deprecated
public void setEnableAutoCommitOnReturn(final boolean autoCommitOnReturn) {
this.autoCommitOnReturn = autoCommitOnReturn;
}
/**
* Sets the EvictionPolicy implementation to use with this connection pool.
*
* @param evictionPolicyClassName The fully qualified class name of the EvictionPolicy implementation
*/
public synchronized void setEvictionPolicyClassName(final String evictionPolicyClassName) {
setConnectionPool(GenericObjectPool::setEvictionPolicyClassName, evictionPolicyClassName);
this.evictionPolicyClassName = evictionPolicyClassName;
}
/**
* @see #getFastFailValidation()
* @param fastFailValidation true means connections created by this factory will fast fail validation
* @since 2.1
*/
public void setFastFailValidation(final boolean fastFailValidation) {
this.fastFailValidation = fastFailValidation;
}
/**
* 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.
*
*
* @param initialSize the number of connections created when the pool is initialized
*/
public synchronized void setInitialSize(final int initialSize) {
this.initialSize = initialSize;
}
/**
* 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.
*
* @param jmxName The JMX name that has been requested for this DataSource
*/
public void setJmxName(final String jmxName) {
this.jmxName = jmxName;
}
/**
* Sets if connection level JMX tracking is requested for this DataSource. If true, each connection will be
* registered for tracking with JMX.
*
* @param registerConnectionMBean connection tracking requested for this DataSource.
*/
public void setRegisterConnectionMBean(final boolean registerConnectionMBean) {
this.registerConnectionMBean = registerConnectionMBean;
}
/**
* Sets the LIFO property. True means the pool behaves as a LIFO queue; false means FIFO.
*
* @param lifo the new value for the LIFO property
*/
public synchronized void setLifo(final boolean lifo) {
this.lifo = lifo;
setConnectionPool(GenericObjectPool::setLifo, lifo);
}
/**
* @param logAbandoned new logAbandoned property value
*/
public void setLogAbandoned(final boolean logAbandoned) {
setAbandoned(AbandonedConfig::setLogAbandoned, logAbandoned);
}
/**
* When {@link #getMaxConnDuration()} 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.
*
* @param logExpiredConnections Whether or not log messages are generated when the pool closes connections due to
* maximum lifetime exceeded.
*/
public void setLogExpiredConnections(final boolean logExpiredConnections) {
this.logExpiredConnections = logExpiredConnections;
}
/**
* BasicDataSource does NOT support this method.
*
*
* Set the login timeout (in seconds) for connecting to the database.
*
*
* Calls {@link #createDataSource()}, so has the side effect of initializing the connection pool.
*
*
* @param loginTimeout The new login timeout, or zero for no timeout
* @throws UnsupportedOperationException If the DataSource implementation does not support the login timeout
* feature.
* @throws SQLException if a database access error occurs
*/
@Override
public void setLoginTimeout(final int loginTimeout) throws SQLException {
// This method isn't supported by the PoolingDataSource returned by the
// createDataSource
throw new UnsupportedOperationException("Not supported by BasicDataSource");
}
/**
* Sets the log writer being used by this data source.
*
* Calls {@link #createDataSource()}, so has the side effect of initializing the connection pool.
*
*
* @param logWriter The new log writer
* @throws SQLException if a database access error occurs
*/
@Override
public void setLogWriter(final PrintWriter logWriter) throws SQLException {
createDataSource().setLogWriter(logWriter);
this.logWriter = logWriter;
}
/**
* Sets the maximum permitted lifetime of a connection. 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.
*
*
* @param maxConnDuration The maximum permitted lifetime of a connection.
* @since 2.10.0
*/
public void setMaxConn(final Duration maxConnDuration) {
this.maxConnDuration = maxConnDuration;
}
/**
* 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.
*
*
* @param maxConnLifetimeMillis The maximum permitted lifetime of a connection in milliseconds.
* @deprecated Use {@link #setMaxConn(Duration)}.
*/
@Deprecated
public void setMaxConnLifetimeMillis(final long maxConnLifetimeMillis) {
this.maxConnDuration = Duration.ofMillis(maxConnLifetimeMillis);
}
/**
* Sets the maximum number of connections that can remain idle in the pool. Excess idle connections are destroyed on
* return to the pool.
*
* @see #getMaxIdle()
* @param maxIdle the new value for maxIdle
*/
public synchronized void setMaxIdle(final int maxIdle) {
this.maxIdle = maxIdle;
setConnectionPool(GenericObjectPool::setMaxIdle, maxIdle);
}
/**
* Sets the value of the {@code 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.
*
*
* @param maxOpenStatements the new maximum number of prepared statements
*/
public synchronized void setMaxOpenPreparedStatements(final int maxOpenStatements) {
this.maxOpenPreparedStatements = maxOpenStatements;
}
/**
* 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.
*
* @param maxTotal the new value for maxTotal
* @see #getMaxTotal()
*/
public synchronized void setMaxTotal(final int maxTotal) {
this.maxTotal = maxTotal;
setConnectionPool(GenericObjectPool::setMaxTotal, maxTotal);
}
/**
* Sets the MaxWaitMillis property. Use -1 to make the pool wait indefinitely.
*
* @param maxWaitDuration the new value for MaxWaitMillis
* @see #getMaxWaitDuration()
* @since 2.10.0
*/
public synchronized void setMaxWait(final Duration maxWaitDuration) {
this.maxWaitDuration = maxWaitDuration;
setConnectionPool(GenericObjectPool::setMaxWait, maxWaitDuration);
}
/**
* Sets the MaxWaitMillis property. Use -1 to make the pool wait indefinitely.
*
* @param maxWaitMillis the new value for MaxWaitMillis
* @see #getMaxWaitDuration()
* @deprecated {@link #setMaxWait(Duration)}.
*/
@Deprecated
public synchronized void setMaxWaitMillis(final long maxWaitMillis) {
setMaxWait(Duration.ofMillis(maxWaitMillis));
}
/**
* Sets the {code minEvictableIdleDuration} property.
*
* @param minEvictableIdleDuration the minimum amount of time an object may sit idle in the pool
* @see #setMinEvictableIdle(Duration)
* @since 2.10.0
*/
public synchronized void setMinEvictableIdle(final Duration minEvictableIdleDuration) {
this.minEvictableIdleDuration = minEvictableIdleDuration;
setConnectionPool(GenericObjectPool::setMinEvictableIdle, minEvictableIdleDuration);
}
/**
* Sets the {code minEvictableIdleDuration} property.
*
* @param minEvictableIdleTimeMillis the minimum amount of time an object may sit idle in the pool
* @see #setMinEvictableIdle(Duration)
* @deprecated Use {@link #setMinEvictableIdle(Duration)}.
*/
@Deprecated
public synchronized void setMinEvictableIdleTimeMillis(final long minEvictableIdleTimeMillis) {
setMinEvictableIdle(Duration.ofMillis(minEvictableIdleTimeMillis));
}
/**
* 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
* {code durationBetweenEvictionRuns} has a positive value.
*
* @param minIdle the new value for minIdle
* @see GenericObjectPool#setMinIdle(int)
*/
public synchronized void setMinIdle(final int minIdle) {
this.minIdle = minIdle;
setConnectionPool(GenericObjectPool::setMinIdle, minIdle);
}
/**
* Sets the value of the {code numTestsPerEvictionRun} property.
*
* @param numTestsPerEvictionRun the new {code numTestsPerEvictionRun} value
* @see #setNumTestsPerEvictionRun(int)
*/
public synchronized void setNumTestsPerEvictionRun(final int numTestsPerEvictionRun) {
this.numTestsPerEvictionRun = numTestsPerEvictionRun;
setConnectionPool(GenericObjectPool::setNumTestsPerEvictionRun, numTestsPerEvictionRun);
}
/**
* Sets the {code 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.
*
*
* @param password new value for the password
*/
public void setPassword(final String password) {
this.password = password;
}
/**
* 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.
*
*
* @param poolingStatements pooling on or off
*/
public synchronized void setPoolPreparedStatements(final boolean poolingStatements) {
this.poolPreparedStatements = poolingStatements;
}
/**
* @param removeAbandonedOnBorrow true means abandoned connections may be removed when connections are borrowed from
* the pool.
* @see #getRemoveAbandonedOnBorrow()
*/
public void setRemoveAbandonedOnBorrow(final boolean removeAbandonedOnBorrow) {
setAbandoned(AbandonedConfig::setRemoveAbandonedOnBorrow, removeAbandonedOnBorrow);
}
/**
* @param removeAbandonedOnMaintenance true means abandoned connections may be removed on pool maintenance.
* @see #getRemoveAbandonedOnMaintenance()
*/
public void setRemoveAbandonedOnMaintenance(final boolean removeAbandonedOnMaintenance) {
setAbandoned(AbandonedConfig::setRemoveAbandonedOnMaintenance, removeAbandonedOnMaintenance);
}
/**
* Sets the timeout before an abandoned connection can be removed.
*
* Setting this property has no effect if {@link #getRemoveAbandonedOnBorrow()} and
* {code getRemoveAbandonedOnMaintenance()} are false.
*
*
* @param removeAbandonedTimeout new abandoned timeout
* @see #getRemoveAbandonedTimeoutDuration()
* @see #getRemoveAbandonedOnBorrow()
* @see #getRemoveAbandonedOnMaintenance()
* @since 2.10.0
*/
public void setRemoveAbandonedTimeout(final Duration removeAbandonedTimeout) {
setAbandoned(AbandonedConfig::setRemoveAbandonedTimeout, removeAbandonedTimeout);
}
/**
* Sets the timeout in seconds before an abandoned connection can be removed.
*
* Setting this property has no effect if {@link #getRemoveAbandonedOnBorrow()} and
* {@link #getRemoveAbandonedOnMaintenance()} are false.
*
*
* @param removeAbandonedTimeout new abandoned timeout in seconds
* @see #getRemoveAbandonedTimeoutDuration()
* @see #getRemoveAbandonedOnBorrow()
* @see #getRemoveAbandonedOnMaintenance()
* @deprecated Use {@link #setRemoveAbandonedTimeout(Duration)}.
*/
@Deprecated
public void setRemoveAbandonedTimeout(final int removeAbandonedTimeout) {
setAbandoned(AbandonedConfig::setRemoveAbandonedTimeout, Duration.ofSeconds(removeAbandonedTimeout));
}
/**
* 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.
*
* @param rollbackOnReturn whether a connection will be rolled back when it is returned to the pool.
*/
public void setRollbackOnReturn(final boolean rollbackOnReturn) {
this.rollbackOnReturn = rollbackOnReturn;
}
/**
* 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.
*
* @param 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 #getSoftMinEvictableIdleTimeMillis
* @since 2.10.0
*/
public synchronized void setSoftMinEvictableIdle(final Duration softMinEvictableIdleTimeMillis) {
this.softMinEvictableIdleDuration = softMinEvictableIdleTimeMillis;
setConnectionPool(GenericObjectPool::setSoftMinEvictableIdle, 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.
*
* @param 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 #getSoftMinEvictableIdleTimeMillis
* @deprecated Use {@link #setSoftMinEvictableIdle(Duration)}.
*/
@Deprecated
public synchronized void setSoftMinEvictableIdleTimeMillis(final long softMinEvictableIdleTimeMillis) {
setSoftMinEvictableIdle(Duration.ofMillis(softMinEvictableIdleTimeMillis));
}
/**
* Sets the {code testOnBorrow} property. This property determines whether or not the pool will validate objects
* before they are borrowed from the pool.
*
* @param testOnBorrow new value for testOnBorrow property
*/
public synchronized void setTestOnBorrow(final boolean testOnBorrow) {
this.testOnBorrow = testOnBorrow;
setConnectionPool(GenericObjectPool::setTestOnBorrow, testOnBorrow);
}
/**
* Sets the {code testOnCreate} property. This property determines whether or not the pool will validate objects
* immediately after they are created by the pool
*
* @param testOnCreate new value for testOnCreate property
*/
public synchronized void setTestOnCreate(final boolean testOnCreate) {
this.testOnCreate = testOnCreate;
setConnectionPool(GenericObjectPool::setTestOnCreate, testOnCreate);
}
/**
* Sets the {@code testOnReturn} property. This property determines whether or not the pool will validate
* objects before they are returned to the pool.
*
* @param testOnReturn new value for testOnReturn property
*/
public synchronized void setTestOnReturn(final boolean testOnReturn) {
this.testOnReturn = testOnReturn;
setConnectionPool(GenericObjectPool::setTestOnReturn, testOnReturn);
}
/**
* Sets the {@code testWhileIdle} property. This property determines whether or not the idle object evictor
* will validate connections.
*
* @param testWhileIdle new value for testWhileIdle property
*/
public synchronized void setTestWhileIdle(final boolean testWhileIdle) {
this.testWhileIdle = testWhileIdle;
setConnectionPool(GenericObjectPool::setTestWhileIdle, testWhileIdle);
}
/**
* Sets the {code durationBetweenEvictionRuns} property.
*
* @param timeBetweenEvictionRunsMillis the new time between evictor runs
* @see #setDurationBetweenEvictionRuns(Duration)
* @since 2.10.0
*/
public synchronized void setDurationBetweenEvictionRuns(final Duration timeBetweenEvictionRunsMillis) {
this.durationBetweenEvictionRuns = timeBetweenEvictionRunsMillis;
setConnectionPool(GenericObjectPool::setTimeBetweenEvictionRuns, timeBetweenEvictionRunsMillis);
}
/**
* Sets the {code durationBetweenEvictionRuns} property.
*
* @param timeBetweenEvictionRunsMillis the new time between evictor runs
* @see #setDurationBetweenEvictionRuns(Duration)
* @deprecated Use {@link #setDurationBetweenEvictionRuns(Duration)}.
*/
@Deprecated
public synchronized void setTimeBetweenEvictionRunsMillis(final long timeBetweenEvictionRunsMillis) {
setDurationBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRunsMillis));
}
/**
* Sets the {code connection string}.
*
* 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.
*
*
* @param connectionString the new value for the JDBC connection connectionString
*/
public synchronized void setUrl(final String connectionString) {
this.connectionString = connectionString;
}
/**
* Sets the {code 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.
*
*
* @param userName the new value for the JDBC connection user name
*/
public void setUsername(final String userName) {
this.userName = userName;
}
/**
* Sets the {code 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.
*
*
* @param validationQuery the new value for the validation query
*/
public void setValidationQuery(final String validationQuery) {
this.validationQuery = isEmpty(validationQuery) ? null : validationQuery;
}
/**
* 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.
*
*
* @param validationQueryTimeoutDuration new validation query timeout value in seconds
* @since 2.10.0
*/
public void setValidationQueryTimeout(final Duration validationQueryTimeoutDuration) {
this.validationQueryTimeoutDuration = validationQueryTimeoutDuration;
}
/**
* 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.
*
*
* @param validationQueryTimeoutSeconds new validation query timeout value in seconds
* @deprecated Use {@link #setValidationQueryTimeout(Duration)}.
*/
@Deprecated
public void setValidationQueryTimeout(final int validationQueryTimeoutSeconds) {
this.validationQueryTimeoutDuration = Duration.ofSeconds(validationQueryTimeoutSeconds);
}
/**
* Starts the datasource.
*
* It is not necessary to call this method before using a newly created BasicDataSource instance, but
* calling it in that context causes the datasource to be immediately initialized (instead of waiting for
* the first {@link #getConnection()} request). Its primary use is to restart and reinitialize a
* datasource that has been closed.
*
* When this method is called after {@link #close()}, connections checked out by clients
* before the datasource was stopped do not count in {@link #getMaxTotal()} or {@link #getNumActive()}.
* For example, if there are 3 connections checked out by clients when {@link #close()} is invoked and they are
* not returned before {@link #start()} is invoked, after this method is called, {@link #getNumActive()} will
* return 0. These connections will be physically closed when they are returned, but they will not count against
* the maximum allowed in the newly started datasource.
*
* @throws SQLException if an error occurs initializing the datasource
*/
@Override
public synchronized void start() throws SQLException {
closed = false;
createDataSource();
}
/**
* Starts the connection pool maintenance task, if configured.
*/
protected void startPoolMaintenance() {
if (connectionPool != null && durationBetweenEvictionRuns.compareTo(Duration.ZERO) > 0) {
connectionPool.setTimeBetweenEvictionRuns(durationBetweenEvictionRuns);
}
}
@Override
public T unwrap(final Class iface) throws SQLException {
if (isWrapperFor(iface)) {
return iface.cast(this);
}
throw new SQLException(this + " is not a wrapper for " + iface);
}
private void updateJmxName(final GenericObjectPoolConfig config) {
if (registeredJmxObjectName == null) {
return;
}
final StringBuilder base = new StringBuilder(registeredJmxObjectName.toString());
base.append(Constants.JMX_CONNECTION_POOL_BASE_EXT);
config.setJmxNameBase(base.toString());
config.setJmxNamePrefix(Constants.JMX_CONNECTION_POOL_PREFIX);
}
}
BasicDataSourceFactory.java 0000664 0000000 0000000 00000062100 14473117325 0033541 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.SQLException;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.function.Consumer;
import java.util.function.Function;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.RefAddr;
import javax.naming.Reference;
import javax.naming.spi.ObjectFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.pool2.impl.BaseObjectPoolConfig;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
/**
* JNDI object factory that creates an instance of {@code BasicDataSource} that has been configured based on the
* {@code RefAddr} values of the specified {@code Reference}, which must match the names and data types of the
* {@code BasicDataSource} bean properties with the following exceptions:
*
* - {@code connectionInitSqls} must be passed to this factory as a single String using semicolon to delimit the
* statements whereas {@code BasicDataSource} requires a collection of Strings.
*
*
* @since 2.0
*/
public class BasicDataSourceFactory implements ObjectFactory {
private static final Log log = LogFactory.getLog(BasicDataSourceFactory.class);
private static final String PROP_DEFAULT_AUTO_COMMIT = "defaultAutoCommit";
private static final String PROP_DEFAULT_READ_ONLY = "defaultReadOnly";
private static final String PROP_DEFAULT_TRANSACTION_ISOLATION = "defaultTransactionIsolation";
private static final String PROP_DEFAULT_CATALOG = "defaultCatalog";
private static final String PROP_DEFAULT_SCHEMA = "defaultSchema";
private static final String PROP_CACHE_STATE = "cacheState";
private static final String PROP_DRIVER_CLASS_NAME = "driverClassName";
private static final String PROP_LIFO = "lifo";
private static final String PROP_MAX_TOTAL = "maxTotal";
private static final String PROP_MAX_IDLE = "maxIdle";
private static final String PROP_MIN_IDLE = "minIdle";
private static final String PROP_INITIAL_SIZE = "initialSize";
private static final String PROP_MAX_WAIT_MILLIS = "maxWaitMillis";
private static final String PROP_TEST_ON_CREATE = "testOnCreate";
private static final String PROP_TEST_ON_BORROW = "testOnBorrow";
private static final String PROP_TEST_ON_RETURN = "testOnReturn";
private static final String PROP_TIME_BETWEEN_EVICTION_RUNS_MILLIS = "timeBetweenEvictionRunsMillis";
private static final String PROP_NUM_TESTS_PER_EVICTION_RUN = "numTestsPerEvictionRun";
private static final String PROP_MIN_EVICTABLE_IDLE_TIME_MILLIS = "minEvictableIdleTimeMillis";
private static final String PROP_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS = "softMinEvictableIdleTimeMillis";
private static final String PROP_EVICTION_POLICY_CLASS_NAME = "evictionPolicyClassName";
private static final String PROP_TEST_WHILE_IDLE = "testWhileIdle";
private static final String PROP_PASSWORD = Constants.KEY_PASSWORD;
private static final String PROP_URL = "url";
private static final String PROP_USER_NAME = "username";
private static final String PROP_VALIDATION_QUERY = "validationQuery";
private static final String PROP_VALIDATION_QUERY_TIMEOUT = "validationQueryTimeout";
private static final String PROP_JMX_NAME = "jmxName";
private static final String PROP_REGISTER_CONNECTION_MBEAN = "registerConnectionMBean";
private static final String PROP_CONNECTION_FACTORY_CLASS_NAME = "connectionFactoryClassName";
/**
* The property name for connectionInitSqls. The associated value String must be of the form [query;]*
*/
private static final String PROP_CONNECTION_INIT_SQLS = "connectionInitSqls";
private static final String PROP_ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED = "accessToUnderlyingConnectionAllowed";
private static final String PROP_REMOVE_ABANDONED_ON_BORROW = "removeAbandonedOnBorrow";
private static final String PROP_REMOVE_ABANDONED_ON_MAINTENANCE = "removeAbandonedOnMaintenance";
private static final String PROP_REMOVE_ABANDONED_TIMEOUT = "removeAbandonedTimeout";
private static final String PROP_LOG_ABANDONED = "logAbandoned";
private static final String PROP_ABANDONED_USAGE_TRACKING = "abandonedUsageTracking";
private static final String PROP_POOL_PREPARED_STATEMENTS = "poolPreparedStatements";
private static final String PROP_CLEAR_STATEMENT_POOL_ON_RETURN = "clearStatementPoolOnReturn";
private static final String PROP_MAX_OPEN_PREPARED_STATEMENTS = "maxOpenPreparedStatements";
private static final String PROP_CONNECTION_PROPERTIES = "connectionProperties";
private static final String PROP_MAX_CONN_LIFETIME_MILLIS = "maxConnLifetimeMillis";
private static final String PROP_LOG_EXPIRED_CONNECTIONS = "logExpiredConnections";
private static final String PROP_ROLLBACK_ON_RETURN = "rollbackOnReturn";
private static final String PROP_ENABLE_AUTO_COMMIT_ON_RETURN = "enableAutoCommitOnReturn";
private static final String PROP_DEFAULT_QUERY_TIMEOUT = "defaultQueryTimeout";
private static final String PROP_FAST_FAIL_VALIDATION = "fastFailValidation";
/**
* Value string must be of the form [STATE_CODE,]*
*/
private static final String PROP_DISCONNECTION_SQL_CODES = "disconnectionSqlCodes";
/*
* Block with obsolete properties from DBCP 1.x. Warn users that these are ignored and they should use the 2.x
* properties.
*/
private static final String NUPROP_MAX_ACTIVE = "maxActive";
private static final String NUPROP_REMOVE_ABANDONED = "removeAbandoned";
private static final String NUPROP_MAXWAIT = "maxWait";
/*
* Block with properties expected in a DataSource This props will not be listed as ignored - we know that they may
* appear in Resource, and not listing them as ignored.
*/
private static final String SILENT_PROP_FACTORY = "factory";
private static final String SILENT_PROP_SCOPE = "scope";
private static final String SILENT_PROP_SINGLETON = "singleton";
private static final String SILENT_PROP_AUTH = "auth";
private static final List ALL_PROPERTY_NAMES = Arrays.asList(PROP_DEFAULT_AUTO_COMMIT, PROP_DEFAULT_READ_ONLY,
PROP_DEFAULT_TRANSACTION_ISOLATION, PROP_DEFAULT_CATALOG, PROP_DEFAULT_SCHEMA, PROP_CACHE_STATE,
PROP_DRIVER_CLASS_NAME, PROP_LIFO, PROP_MAX_TOTAL, PROP_MAX_IDLE, PROP_MIN_IDLE, PROP_INITIAL_SIZE,
PROP_MAX_WAIT_MILLIS, PROP_TEST_ON_CREATE, PROP_TEST_ON_BORROW, PROP_TEST_ON_RETURN,
PROP_TIME_BETWEEN_EVICTION_RUNS_MILLIS, PROP_NUM_TESTS_PER_EVICTION_RUN, PROP_MIN_EVICTABLE_IDLE_TIME_MILLIS,
PROP_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS, PROP_EVICTION_POLICY_CLASS_NAME, PROP_TEST_WHILE_IDLE, PROP_PASSWORD,
PROP_URL, PROP_USER_NAME, PROP_VALIDATION_QUERY, PROP_VALIDATION_QUERY_TIMEOUT, PROP_CONNECTION_INIT_SQLS,
PROP_ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED, PROP_REMOVE_ABANDONED_ON_BORROW, PROP_REMOVE_ABANDONED_ON_MAINTENANCE,
PROP_REMOVE_ABANDONED_TIMEOUT, PROP_LOG_ABANDONED, PROP_ABANDONED_USAGE_TRACKING, PROP_POOL_PREPARED_STATEMENTS,
PROP_CLEAR_STATEMENT_POOL_ON_RETURN,
PROP_MAX_OPEN_PREPARED_STATEMENTS, PROP_CONNECTION_PROPERTIES, PROP_MAX_CONN_LIFETIME_MILLIS,
PROP_LOG_EXPIRED_CONNECTIONS, PROP_ROLLBACK_ON_RETURN, PROP_ENABLE_AUTO_COMMIT_ON_RETURN,
PROP_DEFAULT_QUERY_TIMEOUT, PROP_FAST_FAIL_VALIDATION, PROP_DISCONNECTION_SQL_CODES, PROP_JMX_NAME,
PROP_REGISTER_CONNECTION_MBEAN, PROP_CONNECTION_FACTORY_CLASS_NAME);
/**
* Obsolete properties from DBCP 1.x. with warning strings suggesting new properties. LinkedHashMap will guarantee
* that properties will be listed to output in order of insertion into map.
*/
private static final Map NUPROP_WARNTEXT = new LinkedHashMap<>();
static {
NUPROP_WARNTEXT.put(NUPROP_MAX_ACTIVE,
"Property " + NUPROP_MAX_ACTIVE + " is not used in DBCP2, use " + PROP_MAX_TOTAL + " instead. "
+ PROP_MAX_TOTAL + " default value is " + GenericObjectPoolConfig.DEFAULT_MAX_TOTAL + ".");
NUPROP_WARNTEXT.put(NUPROP_REMOVE_ABANDONED,
"Property " + NUPROP_REMOVE_ABANDONED + " is not used in DBCP2," + " use one or both of "
+ PROP_REMOVE_ABANDONED_ON_BORROW + " or " + PROP_REMOVE_ABANDONED_ON_MAINTENANCE + " instead. "
+ "Both have default value set to false.");
NUPROP_WARNTEXT.put(NUPROP_MAXWAIT,
"Property " + NUPROP_MAXWAIT + " is not used in DBCP2" + " , use " + PROP_MAX_WAIT_MILLIS + " instead. "
+ PROP_MAX_WAIT_MILLIS + " default value is " + BaseObjectPoolConfig.DEFAULT_MAX_WAIT
+ ".");
}
/**
* Silent Properties. These properties will not be listed as ignored - we know that they may appear in JDBC Resource
* references, and we will not list them as ignored.
*/
private static final List SILENT_PROPERTIES = new ArrayList<>();
static {
SILENT_PROPERTIES.add(SILENT_PROP_FACTORY);
SILENT_PROPERTIES.add(SILENT_PROP_SCOPE);
SILENT_PROPERTIES.add(SILENT_PROP_SINGLETON);
SILENT_PROPERTIES.add(SILENT_PROP_AUTH);
}
private static void accept(final Properties properties, final String name, final Function parser, final Consumer consumer) {
getOptional(properties, name).ifPresent(v -> consumer.accept(parser.apply(v)));
}
private static void acceptBoolean(final Properties properties, final String name, final Consumer consumer) {
accept(properties, name, Boolean::parseBoolean, consumer);
}
private static void acceptDurationOfMillis(final Properties properties, final String name, final Consumer consumer) {
accept(properties, name, s -> Duration.ofMillis(Long.parseLong(s)), consumer);
}
private static void acceptDurationOfSeconds(final Properties properties, final String name, final Consumer consumer) {
accept(properties, name, s -> Duration.ofSeconds(Long.parseLong(s)), consumer);
}
private static void acceptInt(final Properties properties, final String name, final Consumer consumer) {
accept(properties, name, Integer::parseInt, consumer);
}
private static void acceptString(final Properties properties, final String name, final Consumer consumer) {
accept(properties, name, Function.identity(), consumer);
}
/**
* Creates and configures a {@link BasicDataSource} instance based on the given properties.
*
* @param properties
* The data source configuration properties.
* @return A new a {@link BasicDataSource} instance based on the given properties.
* @throws SQLException
* Thrown when an error occurs creating the data source.
*/
public static BasicDataSource createDataSource(final Properties properties) throws SQLException {
final BasicDataSource dataSource = new BasicDataSource();
acceptBoolean(properties, PROP_DEFAULT_AUTO_COMMIT, dataSource::setDefaultAutoCommit);
acceptBoolean(properties, PROP_DEFAULT_READ_ONLY, dataSource::setDefaultReadOnly);
getOptional(properties, PROP_DEFAULT_TRANSACTION_ISOLATION).ifPresent(value -> {
value = value.toUpperCase(Locale.ROOT);
int level = PoolableConnectionFactory.UNKNOWN_TRANSACTION_ISOLATION;
if ("NONE".equals(value)) {
level = Connection.TRANSACTION_NONE;
} else if ("READ_COMMITTED".equals(value)) {
level = Connection.TRANSACTION_READ_COMMITTED;
} else if ("READ_UNCOMMITTED".equals(value)) {
level = Connection.TRANSACTION_READ_UNCOMMITTED;
} else if ("REPEATABLE_READ".equals(value)) {
level = Connection.TRANSACTION_REPEATABLE_READ;
} else if ("SERIALIZABLE".equals(value)) {
level = Connection.TRANSACTION_SERIALIZABLE;
} else {
try {
level = Integer.parseInt(value);
} catch (final NumberFormatException e) {
System.err.println("Could not parse defaultTransactionIsolation: " + value);
System.err.println("WARNING: defaultTransactionIsolation not set");
System.err.println("using default value of database driver");
level = PoolableConnectionFactory.UNKNOWN_TRANSACTION_ISOLATION;
}
}
dataSource.setDefaultTransactionIsolation(level);
});
acceptString(properties, PROP_DEFAULT_SCHEMA, dataSource::setDefaultSchema);
acceptString(properties, PROP_DEFAULT_CATALOG, dataSource::setDefaultCatalog);
acceptBoolean(properties, PROP_CACHE_STATE, dataSource::setCacheState);
acceptString(properties, PROP_DRIVER_CLASS_NAME, dataSource::setDriverClassName);
acceptBoolean(properties, PROP_LIFO, dataSource::setLifo);
acceptInt(properties, PROP_MAX_TOTAL, dataSource::setMaxTotal);
acceptInt(properties, PROP_MAX_IDLE, dataSource::setMaxIdle);
acceptInt(properties, PROP_MIN_IDLE, dataSource::setMinIdle);
acceptInt(properties, PROP_INITIAL_SIZE, dataSource::setInitialSize);
acceptDurationOfMillis(properties, PROP_MAX_WAIT_MILLIS, dataSource::setMaxWait);
acceptBoolean(properties, PROP_TEST_ON_CREATE, dataSource::setTestOnCreate);
acceptBoolean(properties, PROP_TEST_ON_BORROW, dataSource::setTestOnBorrow);
acceptBoolean(properties, PROP_TEST_ON_RETURN, dataSource::setTestOnReturn);
acceptDurationOfMillis(properties, PROP_TIME_BETWEEN_EVICTION_RUNS_MILLIS, dataSource::setDurationBetweenEvictionRuns);
acceptInt(properties, PROP_NUM_TESTS_PER_EVICTION_RUN, dataSource::setNumTestsPerEvictionRun);
acceptDurationOfMillis(properties, PROP_MIN_EVICTABLE_IDLE_TIME_MILLIS, dataSource::setMinEvictableIdle);
acceptDurationOfMillis(properties, PROP_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS, dataSource::setSoftMinEvictableIdle);
acceptString(properties, PROP_EVICTION_POLICY_CLASS_NAME, dataSource::setEvictionPolicyClassName);
acceptBoolean(properties, PROP_TEST_WHILE_IDLE, dataSource::setTestWhileIdle);
acceptString(properties, PROP_PASSWORD, dataSource::setPassword);
acceptString(properties, PROP_URL, dataSource::setUrl);
acceptString(properties, PROP_USER_NAME, dataSource::setUsername);
acceptString(properties, PROP_VALIDATION_QUERY, dataSource::setValidationQuery);
acceptDurationOfSeconds(properties, PROP_VALIDATION_QUERY_TIMEOUT, dataSource::setValidationQueryTimeout);
acceptBoolean(properties, PROP_ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED, dataSource::setAccessToUnderlyingConnectionAllowed);
acceptBoolean(properties, PROP_REMOVE_ABANDONED_ON_BORROW, dataSource::setRemoveAbandonedOnBorrow);
acceptBoolean(properties, PROP_REMOVE_ABANDONED_ON_MAINTENANCE, dataSource::setRemoveAbandonedOnMaintenance);
acceptDurationOfSeconds(properties, PROP_REMOVE_ABANDONED_TIMEOUT, dataSource::setRemoveAbandonedTimeout);
acceptBoolean(properties, PROP_LOG_ABANDONED, dataSource::setLogAbandoned);
acceptBoolean(properties, PROP_ABANDONED_USAGE_TRACKING, dataSource::setAbandonedUsageTracking);
acceptBoolean(properties, PROP_POOL_PREPARED_STATEMENTS, dataSource::setPoolPreparedStatements);
acceptBoolean(properties, PROP_CLEAR_STATEMENT_POOL_ON_RETURN, dataSource::setClearStatementPoolOnReturn);
acceptInt(properties, PROP_MAX_OPEN_PREPARED_STATEMENTS, dataSource::setMaxOpenPreparedStatements);
getOptional(properties, PROP_CONNECTION_INIT_SQLS).ifPresent(v -> dataSource.setConnectionInitSqls(parseList(v, ';')));
final String value = properties.getProperty(PROP_CONNECTION_PROPERTIES);
if (value != null) {
for (final Object key : getProperties(value).keySet()) {
final String propertyName = Objects.toString(key, null);
dataSource.addConnectionProperty(propertyName, getProperties(value).getProperty(propertyName));
}
}
acceptDurationOfMillis(properties, PROP_MAX_CONN_LIFETIME_MILLIS, dataSource::setMaxConn);
acceptBoolean(properties, PROP_LOG_EXPIRED_CONNECTIONS, dataSource::setLogExpiredConnections);
acceptString(properties, PROP_JMX_NAME, dataSource::setJmxName);
acceptBoolean(properties, PROP_REGISTER_CONNECTION_MBEAN, dataSource::setRegisterConnectionMBean);
acceptBoolean(properties, PROP_ENABLE_AUTO_COMMIT_ON_RETURN, dataSource::setAutoCommitOnReturn);
acceptBoolean(properties, PROP_ROLLBACK_ON_RETURN, dataSource::setRollbackOnReturn);
acceptDurationOfSeconds(properties, PROP_DEFAULT_QUERY_TIMEOUT, dataSource::setDefaultQueryTimeout);
acceptBoolean(properties, PROP_FAST_FAIL_VALIDATION, dataSource::setFastFailValidation);
getOptional(properties, PROP_DISCONNECTION_SQL_CODES).ifPresent(v -> dataSource.setDisconnectionSqlCodes(parseList(v, ',')));
acceptString(properties, PROP_CONNECTION_FACTORY_CLASS_NAME, dataSource::setConnectionFactoryClassName);
// DBCP-215
// Trick to make sure that initialSize connections are created
if (dataSource.getInitialSize() > 0) {
dataSource.getLogWriter();
}
// Return the configured DataSource instance
return dataSource;
}
private static Optional getOptional(final Properties properties, final String name) {
return Optional.ofNullable(properties.getProperty(name));
}
/**
* Parse properties from the string. Format of the string must be [propertyName=property;]*
*
* @param propText The source text
* @return Properties A new Properties instance
* @throws SQLException When a paring exception occurs
*/
private static Properties getProperties(final String propText) throws SQLException {
final Properties p = new Properties();
if (propText != null) {
try {
p.load(new ByteArrayInputStream(propText.replace(';', '\n').getBytes(StandardCharsets.ISO_8859_1)));
} catch (IOException e) {
throw new SQLException(propText, e);
}
}
return p;
}
/**
* Parse list of property values from a delimited string
*
* @param value
* delimited list of values
* @param delimiter
* character used to separate values in the list
* @return String Collection of values
*/
private static Collection parseList(final String value, final char delimiter) {
final StringTokenizer tokenizer = new StringTokenizer(value, Character.toString(delimiter));
final Collection tokens = new ArrayList<>(tokenizer.countTokens());
while (tokenizer.hasMoreTokens()) {
tokens.add(tokenizer.nextToken());
}
return tokens;
}
/**
* Creates and return a new {@code BasicDataSource} instance. If no instance can be created, return
* {@code null} instead.
*
* @param obj
* The possibly null object containing location or reference information that can be used in creating an
* object
* @param name
* The name of this object relative to {@code nameCtx}
* @param nameCtx
* The context relative to which the {@code name} parameter is specified, or {@code null} if
* {@code name} is relative to the default initial context
* @param environment
* The possibly null environment that is used in creating this object
*
* @throws SQLException
* if an exception occurs creating the instance
*/
@Override
public Object getObjectInstance(final Object obj, final Name name, final Context nameCtx,
final Hashtable environment) throws SQLException {
// We only know how to deal with {@code javax.naming.Reference}s
// that specify a class name of "javax.sql.DataSource"
if (obj == null || !(obj instanceof Reference)) {
return null;
}
final Reference ref = (Reference) obj;
if (!"javax.sql.DataSource".equals(ref.getClassName())) {
return null;
}
// Check property names and log warnings about obsolete and / or unknown properties
final List warnMessages = new ArrayList<>();
final List infoMessages = new ArrayList<>();
validatePropertyNames(ref, name, warnMessages, infoMessages);
warnMessages.forEach(log::warn);
infoMessages.forEach(log::info);
final Properties properties = new Properties();
ALL_PROPERTY_NAMES.forEach(propertyName -> {
final RefAddr ra = ref.get(propertyName);
if (ra != null) {
properties.setProperty(propertyName, Objects.toString(ra.getContent(), null));
}
});
return createDataSource(properties);
}
/**
* Collects warnings and info messages. Warnings are generated when an obsolete property is set. Unknown properties
* generate info messages.
*
* @param ref
* Reference to check properties of
* @param name
* Name provided to getObject
* @param warnMessages
* container for warning messages
* @param infoMessages
* container for info messages
*/
private void validatePropertyNames(final Reference ref, final Name name, final List warnMessages,
final List infoMessages) {
final String nameString = name != null ? "Name = " + name.toString() + " " : "";
if (NUPROP_WARNTEXT != null && !NUPROP_WARNTEXT.isEmpty()) {
NUPROP_WARNTEXT.forEach((propertyName, value) -> {
final RefAddr ra = ref.get(propertyName);
if (ra != null && !ALL_PROPERTY_NAMES.contains(ra.getType())) {
final StringBuilder stringBuilder = new StringBuilder(nameString);
final String propertyValue = Objects.toString(ra.getContent(), null);
stringBuilder.append(value).append(" You have set value of \"").append(propertyValue).append("\" for \"").append(propertyName)
.append("\" property, which is being ignored.");
warnMessages.add(stringBuilder.toString());
}
});
}
final Enumeration allRefAddrs = ref.getAll();
while (allRefAddrs.hasMoreElements()) {
final RefAddr ra = allRefAddrs.nextElement();
final String propertyName = ra.getType();
// If property name is not in the properties list, we haven't warned on it
// and it is not in the "silent" list, tell user we are ignoring it.
if (!(ALL_PROPERTY_NAMES.contains(propertyName) || NUPROP_WARNTEXT.containsKey(propertyName) || SILENT_PROPERTIES.contains(propertyName))) {
final String propertyValue = Objects.toString(ra.getContent(), null);
final StringBuilder stringBuilder = new StringBuilder(nameString);
stringBuilder.append("Ignoring unknown property: ").append("value of \"").append(propertyValue).append("\" for \"").append(propertyName)
.append("\" property");
infoMessages.add(stringBuilder.toString());
}
}
}
}
BasicDataSourceMXBean.java 0000664 0000000 0000000 00000002643 14473117325 0033252 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
/**
* Interface to keep API compatibility. Methods listed here are not made available to
* JMX.
*
* As of 2.9.0, this interface extends {@link DataSourceMXBean}.
*
*
* @since 2.0
*/
public interface BasicDataSourceMXBean extends DataSourceMXBean {
/**
* See {@link BasicDataSource#getPassword()}
*
* @return {@link BasicDataSource#getPassword()}
* @deprecated exposing password via JMX is an Information Exposure issue.
*/
@Deprecated
String getPassword();
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/ConnectionFactory.java 0000664 0000000 0000000 00000002502 14473117325 0032723 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.SQLException;
/**
* Abstract factory interface for creating {@link java.sql.Connection}s.
*
* @since 2.0
*/
public interface ConnectionFactory {
/**
* Create a new {@link java.sql.Connection} in an implementation specific fashion.
*
* @return a new {@link java.sql.Connection}
* @throws SQLException
* if a database error occurs creating the connection
*/
Connection createConnection() throws SQLException;
}
ConnectionFactoryFactory.java 0000664 0000000 0000000 00000006577 14473117325 0034214 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Driver;
import java.sql.SQLException;
import java.util.Properties;
/*
* Creates {@link ConnectionFactory} instances.
*
* @since 2.7.0
*/
final class ConnectionFactoryFactory {
/**
* Creates a new {@link DriverConnectionFactory} allowing for an override through
* {@link BasicDataSource#getDriverClassName()}.
*
* @param basicDataSource Configures creation.
* @param driver The JDBC driver.
* @return a new {@link DriverConnectionFactory} allowing for a {@link BasicDataSource#getDriverClassName()}
* override.
* @throws SQLException Thrown when instantiation fails.
*/
static ConnectionFactory createConnectionFactory(final BasicDataSource basicDataSource, final Driver driver)
throws SQLException {
final Properties connectionProperties = basicDataSource.getConnectionProperties();
final String url = basicDataSource.getUrl();
// Set up the driver connection factory we will use
final String user = basicDataSource.getUsername();
if (user != null) {
connectionProperties.put(Constants.KEY_USER, user);
} else {
basicDataSource.log(String.format("DBCP DataSource configured without a '%s'", Constants.KEY_USER));
}
final String pwd = basicDataSource.getPassword();
if (pwd != null) {
connectionProperties.put(Constants.KEY_PASSWORD, pwd);
} else {
basicDataSource.log(String.format("DBCP DataSource configured without a '%s'", Constants.KEY_PASSWORD));
}
final String connectionFactoryClassName = basicDataSource.getConnectionFactoryClassName();
if (connectionFactoryClassName != null) {
try {
final Class connectionFactoryFromCCL = Class.forName(connectionFactoryClassName);
return (ConnectionFactory) connectionFactoryFromCCL
.getConstructor(Driver.class, String.class, Properties.class)
.newInstance(driver, url, connectionProperties);
} catch (final Exception t) {
final String message = "Cannot load ConnectionFactory implementation '" + connectionFactoryClassName
+ "'";
basicDataSource.log(message, t);
throw new SQLException(message, t);
}
}
// Defaults to DriverConnectionFactory
return new DriverConnectionFactory(driver, url, connectionProperties);
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/Constants.java 0000664 0000000 0000000 00000003213 14473117325 0031250 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
/**
* Constants.
*
* @since 2.0
*/
public class Constants {
public static final String JMX_CONNECTION_POOL_BASE_EXT = ",connectionpool=";
public static final String JMX_CONNECTION_POOL_PREFIX = "connections";
public static final String JMX_CONNECTION_BASE_EXT = JMX_CONNECTION_POOL_BASE_EXT + JMX_CONNECTION_POOL_PREFIX
+ ",connection=";
public static final String JMX_STATEMENT_POOL_BASE_EXT = JMX_CONNECTION_BASE_EXT;
public static final String JMX_STATEMENT_POOL_PREFIX = ",statementpool=statements";
/**
* JDBC properties and URL key for passwords.
*
* @since 2.9.0
*/
public static final String KEY_PASSWORD = "password";
/**
* JDBC properties and URL key for users.
*
* @since 2.9.0
*/
public static final String KEY_USER = "user";
}
DataSourceConnectionFactory.java 0000664 0000000 0000000 00000006476 14473117325 0034635 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
/**
* A {@link DataSource}-based implementation of {@link ConnectionFactory}.
*
* @since 2.0
*/
public class DataSourceConnectionFactory implements ConnectionFactory {
private final DataSource dataSource;
private final String userName;
private final char[] userPassword;
/**
* Constructs an instance for the given DataSource.
*
* @param dataSource
* The DataSource for this factory.
*/
public DataSourceConnectionFactory(final DataSource dataSource) {
this(dataSource, null, (char[]) null);
}
/**
* Constructs an instance for the given DataSource.
*
* @param dataSource
* The DataSource for this factory.
* @param userName
* The user name.
* @param userPassword
* The user password.
* @since 2.4.0
*/
public DataSourceConnectionFactory(final DataSource dataSource, final String userName, final char[] userPassword) {
this.dataSource = dataSource;
this.userName = userName;
this.userPassword = Utils.clone(userPassword);
}
/**
* Constructs an instance for the given DataSource.
*
* @param dataSource
* The DataSource for this factory.
* @param userName
* The user name.
* @param password
* The user password.
*/
public DataSourceConnectionFactory(final DataSource dataSource, final String userName, final String password) {
this.dataSource = dataSource;
this.userName = userName;
this.userPassword = Utils.toCharArray(password);
}
@Override
public Connection createConnection() throws SQLException {
if (null == userName && null == userPassword) {
return dataSource.getConnection();
}
return dataSource.getConnection(userName, Utils.toString(userPassword));
}
/**
* @return The data source.
* @since 2.6.0
*/
public DataSource getDataSource() {
return dataSource;
}
/**
* @return The user name.
* @since 2.6.0
*/
public String getUserName() {
return userName;
}
/**
* @return The user password.
* @since 2.6.0
*/
public char[] getUserPassword() {
return Utils.clone(userPassword);
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/DataSourceMXBean.java 0000664 0000000 0000000 00000021717 14473117325 0032372 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.SQLException;
/**
* Defines the methods that will be made available via
* JMX.
*
* @since 2.9.0
*/
public interface DataSourceMXBean {
/**
* See {@link BasicDataSource#getAbandonedUsageTracking()}.
*
* @return {@link BasicDataSource#getAbandonedUsageTracking()}
*/
boolean getAbandonedUsageTracking();
/**
* See {@link BasicDataSource#getCacheState()}.
*
* @return {@link BasicDataSource#getCacheState()}.
*/
boolean getCacheState();
/**
* See {@link BasicDataSource#getConnectionInitSqlsAsArray()}.
*
* @return {@link BasicDataSource#getConnectionInitSqlsAsArray()}.
*/
String[] getConnectionInitSqlsAsArray();
/**
* See {@link BasicDataSource#getDefaultAutoCommit()}.
*
* @return {@link BasicDataSource#getDefaultAutoCommit()}.
*/
Boolean getDefaultAutoCommit();
/**
* See {@link BasicDataSource#getDefaultCatalog()}.
*
* @return {@link BasicDataSource#getDefaultCatalog()}.
*/
String getDefaultCatalog();
/**
* See {@link BasicDataSource#getDefaultReadOnly()}.
*
* @return {@link BasicDataSource#getDefaultReadOnly()}.
*/
Boolean getDefaultReadOnly();
/**
* See {@link BasicDataSource#getDefaultSchema()}.
*
* @return {@link BasicDataSource#getDefaultSchema()}.
* @since 2.5.0
*/
default String getDefaultSchema() {
return null;
}
/**
* See {@link BasicDataSource#getDefaultTransactionIsolation()}.
*
* @return {@link BasicDataSource#getDefaultTransactionIsolation()}.
*/
int getDefaultTransactionIsolation();
/**
* See {@link BasicDataSource#getDisconnectionSqlCodesAsArray()}.
*
* @return {@link BasicDataSource#getDisconnectionSqlCodesAsArray()}.
* @since 2.1
*/
String[] getDisconnectionSqlCodesAsArray();
/**
* See {@link BasicDataSource#getDriverClassName()}.
*
* @return {@link BasicDataSource#getDriverClassName()}.
*/
String getDriverClassName();
/**
* See {@link BasicDataSource#getFastFailValidation()}.
*
* @return {@link BasicDataSource#getFastFailValidation()}.
* @since 2.1
*/
boolean getFastFailValidation();
/**
* See {@link BasicDataSource#getInitialSize()}.
*
* @return {@link BasicDataSource#getInitialSize()}.
*/
int getInitialSize();
/**
* See {@link BasicDataSource#getLifo()}.
*
* @return {@link BasicDataSource#getLifo()}.
*/
boolean getLifo();
/**
* See {@link BasicDataSource#getLogAbandoned()}.
*
* @return {@link BasicDataSource#getLogAbandoned()}.
*/
boolean getLogAbandoned();
/**
* See {@link BasicDataSource#getLogExpiredConnections()}.
*
* @return {@link BasicDataSource#getLogExpiredConnections()}.
* @since 2.1
*/
boolean getLogExpiredConnections();
/**
* See {@link BasicDataSource#getMaxConnLifetimeMillis()}.
*
* @return {@link BasicDataSource#getMaxConnLifetimeMillis()}.
*/
long getMaxConnLifetimeMillis();
/**
* See {@link BasicDataSource#getMaxIdle()}.
*
* @return {@link BasicDataSource#getMaxIdle()}.
*/
int getMaxIdle();
/**
* See {@link BasicDataSource#getMaxOpenPreparedStatements()}.
*
* @return {@link BasicDataSource#getMaxOpenPreparedStatements()}.
*/
int getMaxOpenPreparedStatements();
/**
* See {@link BasicDataSource#getMaxTotal()}.
*
* @return {@link BasicDataSource#getMaxTotal()}.
*/
int getMaxTotal();
/**
* See {@link BasicDataSource#getMaxWaitMillis()}.
*
* @return {@link BasicDataSource#getMaxWaitMillis()}.
*/
long getMaxWaitMillis();
/**
* See {@link BasicDataSource#getMinEvictableIdleTimeMillis()}.
*
* @return {@link BasicDataSource#getMinEvictableIdleTimeMillis()}.
*/
long getMinEvictableIdleTimeMillis();
/**
* See {@link BasicDataSource#getMinIdle()}.
*
* @return {@link BasicDataSource#getMinIdle()}.
*/
int getMinIdle();
/**
* See {@link BasicDataSource#getNumActive()}.
*
* @return {@link BasicDataSource#getNumActive()}.
*/
int getNumActive();
/**
* See {@link BasicDataSource#getNumIdle()}.
*
* @return {@link BasicDataSource#getNumIdle()}.
*/
int getNumIdle();
/**
* See {@link BasicDataSource#getNumTestsPerEvictionRun()}.
*
* @return {@link BasicDataSource#getNumTestsPerEvictionRun()}.
*/
int getNumTestsPerEvictionRun();
/**
* See {@link BasicDataSource#getRemoveAbandonedOnBorrow()}.
*
* @return {@link BasicDataSource#getRemoveAbandonedOnBorrow()}.
*/
boolean getRemoveAbandonedOnBorrow();
/**
* See {@link BasicDataSource#getRemoveAbandonedOnMaintenance()}.
*
* @return {@link BasicDataSource#getRemoveAbandonedOnMaintenance()}.
*/
boolean getRemoveAbandonedOnMaintenance();
/**
* See {@link BasicDataSource#getRemoveAbandonedTimeout()}.
*
* @return {@link BasicDataSource#getRemoveAbandonedTimeout()}.
*/
int getRemoveAbandonedTimeout();
/**
* See {@link BasicDataSource#getSoftMinEvictableIdleTimeMillis()}.
*
* @return {@link BasicDataSource#getSoftMinEvictableIdleTimeMillis()}.
*/
long getSoftMinEvictableIdleTimeMillis();
/**
* See {@link BasicDataSource#getTestOnBorrow()}.
*
* @return {@link BasicDataSource#getTestOnBorrow()}.
*/
boolean getTestOnBorrow();
/**
* See {@link BasicDataSource#getTestOnCreate()}.
*
* @return {@link BasicDataSource#getTestOnCreate()}.
*/
boolean getTestOnCreate();
/**
* See {@link BasicDataSource#getTestWhileIdle()}.
*
* @return {@link BasicDataSource#getTestWhileIdle()}.
*/
boolean getTestWhileIdle();
/**
* See {@link BasicDataSource#getTimeBetweenEvictionRunsMillis()}.
*
* @return {@link BasicDataSource#getTimeBetweenEvictionRunsMillis()}.
*/
long getTimeBetweenEvictionRunsMillis();
/**
* See {@link BasicDataSource#getUrl()}.
*
* @return {@link BasicDataSource#getUrl()}.
*/
String getUrl();
/**
* See {@link BasicDataSource#getUsername()}.
*
* @return {@link BasicDataSource#getUsername()}.
*/
String getUsername();
/**
* See {@link BasicDataSource#getValidationQuery()}.
*
* @return {@link BasicDataSource#getValidationQuery()}.
*/
String getValidationQuery();
/**
* See {@link BasicDataSource#getValidationQueryTimeout()}.
*
* @return {@link BasicDataSource#getValidationQueryTimeout()}.
*/
int getValidationQueryTimeout();
/**
* See {@link BasicDataSource#isAccessToUnderlyingConnectionAllowed()}.
*
* @return {@link BasicDataSource#isAccessToUnderlyingConnectionAllowed()}.
*/
boolean isAccessToUnderlyingConnectionAllowed();
/**
* See {@link BasicDataSource#isClearStatementPoolOnReturn()}.
*
* @return {@link BasicDataSource#isClearStatementPoolOnReturn()}.
* @since 2.8.0
*/
default boolean isClearStatementPoolOnReturn() {
return false;
}
/**
* See {@link BasicDataSource#isClosed()}.
*
* @return {@link BasicDataSource#isClosed()}.
*/
boolean isClosed();
/**
* See {@link BasicDataSource#isPoolPreparedStatements()}.
*
* @return {@link BasicDataSource#isPoolPreparedStatements()}.
*/
boolean isPoolPreparedStatements();
/**
* See {@link BasicDataSource#restart()}
*
* @throws SQLException if an error occurs initializing the data source.
*
* @since 2.8.0
*/
default void restart() throws SQLException {
// do nothing by default?
}
/**
* See {@link BasicDataSource#start()}
*
* @throws SQLException if an error occurs initializing the data source.
*
* @since 2.8.0
*/
default void start() throws SQLException {
// do nothing
}
}
DelegatingCallableStatement.java 0000664 0000000 0000000 00000122643 14473117325 0034576 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.Ref;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLType;
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Map;
/**
* A base delegating implementation of {@link CallableStatement}.
*
* All of the methods from the {@link CallableStatement} interface simply call the corresponding method on the
* "delegate" provided in my constructor.
*
*
* Extends AbandonedTrace to implement Statement tracking and logging of code which created the Statement. Tracking the
* Statement ensures that the Connection which created it can close any open Statement's on Connection close.
*
*
* @since 2.0
*/
public class DelegatingCallableStatement extends DelegatingPreparedStatement implements CallableStatement {
/**
* Creates a wrapper for the Statement which traces this Statement to the Connection which created it and the code
* which created it.
*
* @param connection
* the {@link DelegatingConnection} that created this statement
* @param statement
* the {@link CallableStatement} to delegate all calls to
*/
public DelegatingCallableStatement(final DelegatingConnection connection, final CallableStatement statement) {
super(connection, statement);
}
@Override
public Array getArray(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getArray(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Array getArray(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getArray(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public BigDecimal getBigDecimal(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBigDecimal(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/** @deprecated Use {@link #getBigDecimal(int)} or {@link #getBigDecimal(String)} */
@Override
@Deprecated
public BigDecimal getBigDecimal(final int parameterIndex, final int scale) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBigDecimal(parameterIndex, scale);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public BigDecimal getBigDecimal(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBigDecimal(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Blob getBlob(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBlob(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Blob getBlob(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBlob(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public boolean getBoolean(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBoolean(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean getBoolean(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBoolean(parameterName);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public byte getByte(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getByte(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public byte getByte(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getByte(parameterName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public byte[] getBytes(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBytes(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public byte[] getBytes(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getBytes(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Reader getCharacterStream(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getCharacterStream(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Reader getCharacterStream(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getCharacterStream(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Clob getClob(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getClob(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Clob getClob(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getClob(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getDate(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final int parameterIndex, final Calendar cal) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getDate(parameterIndex, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getDate(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final String parameterName, final Calendar cal) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getDate(parameterName, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
private CallableStatement getDelegateCallableStatement() {
return (CallableStatement) getDelegate();
}
@Override
public double getDouble(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getDouble(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public double getDouble(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getDouble(parameterName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public float getFloat(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getFloat(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public float getFloat(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getFloat(parameterName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getInt(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getInt(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getInt(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getInt(parameterName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public long getLong(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getLong(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public long getLong(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getLong(parameterName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public Reader getNCharacterStream(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getNCharacterStream(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Reader getNCharacterStream(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getNCharacterStream(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public NClob getNClob(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getNClob(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public NClob getNClob(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getNClob(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getNString(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getNString(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getNString(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getNString(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getObject(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public T getObject(final int parameterIndex, final Class type) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getObject(parameterIndex, type);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final int i, final Map> map) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getObject(i, map);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getObject(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public T getObject(final String parameterName, final Class type) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getObject(parameterName, type);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final String parameterName, final Map> map) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getObject(parameterName, map);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Ref getRef(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getRef(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Ref getRef(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getRef(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public RowId getRowId(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getRowId(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public RowId getRowId(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getRowId(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public short getShort(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getShort(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public short getShort(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getShort(parameterName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public SQLXML getSQLXML(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getSQLXML(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public SQLXML getSQLXML(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getSQLXML(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getString(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getString(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getString(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getString(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTime(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final int parameterIndex, final Calendar cal) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTime(parameterIndex, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTime(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final String parameterName, final Calendar cal) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTime(parameterName, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTimestamp(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final int parameterIndex, final Calendar cal) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTimestamp(parameterIndex, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTimestamp(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final String parameterName, final Calendar cal) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getTimestamp(parameterName, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public URL getURL(final int parameterIndex) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getURL(parameterIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public URL getURL(final String parameterName) throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().getURL(parameterName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public void registerOutParameter(final int parameterIndex, final int sqlType) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void registerOutParameter(final int parameterIndex, final int sqlType, final int scale) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, scale);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void registerOutParameter(final int paramIndex, final int sqlType, final String typeName)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(paramIndex, sqlType, typeName);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void registerOutParameter(final int parameterIndex, final SQLType sqlType) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void registerOutParameter(final int parameterIndex, final SQLType sqlType, final int scale)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, scale);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void registerOutParameter(final int parameterIndex, final SQLType sqlType, final String typeName)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, typeName);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void registerOutParameter(final String parameterName, final int sqlType) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterName, sqlType);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void registerOutParameter(final String parameterName, final int sqlType, final int scale)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, scale);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void registerOutParameter(final String parameterName, final int sqlType, final String typeName)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, typeName);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void registerOutParameter(final String parameterName, final SQLType sqlType) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterName, sqlType);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void registerOutParameter(final String parameterName, final SQLType sqlType, final int scale)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, scale);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void registerOutParameter(final String parameterName, final SQLType sqlType, final String typeName)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, typeName);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setAsciiStream(final String parameterName, final InputStream inputStream) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setAsciiStream(parameterName, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setAsciiStream(final String parameterName, final InputStream x, final int length) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setAsciiStream(parameterName, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setAsciiStream(final String parameterName, final InputStream inputStream, final long length)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setAsciiStream(parameterName, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBigDecimal(final String parameterName, final BigDecimal x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBigDecimal(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBinaryStream(final String parameterName, final InputStream inputStream) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBinaryStream(parameterName, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBinaryStream(final String parameterName, final InputStream x, final int length) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBinaryStream(parameterName, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBinaryStream(final String parameterName, final InputStream inputStream, final long length)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBinaryStream(parameterName, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBlob(final String parameterName, final Blob blob) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBlob(parameterName, blob);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBlob(final String parameterName, final InputStream inputStream) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBlob(parameterName, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBlob(final String parameterName, final InputStream inputStream, final long length)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBlob(parameterName, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBoolean(final String parameterName, final boolean x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBoolean(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setByte(final String parameterName, final byte x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setByte(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBytes(final String parameterName, final byte[] x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setBytes(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setCharacterStream(final String parameterName, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setCharacterStream(parameterName, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setCharacterStream(final String parameterName, final Reader reader, final int length)
throws SQLException {
checkOpen();
getDelegateCallableStatement().setCharacterStream(parameterName, reader, length);
}
@Override
public void setCharacterStream(final String parameterName, final Reader reader, final long length)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setCharacterStream(parameterName, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setClob(final String parameterName, final Clob clob) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setClob(parameterName, clob);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setClob(final String parameterName, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setClob(parameterName, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setClob(final String parameterName, final Reader reader, final long length) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setClob(parameterName, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setDate(final String parameterName, final Date x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setDate(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setDate(final String parameterName, final Date x, final Calendar cal) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setDate(parameterName, x, cal);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setDouble(final String parameterName, final double x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setDouble(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setFloat(final String parameterName, final float x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setFloat(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setInt(final String parameterName, final int x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setInt(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setLong(final String parameterName, final long x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setLong(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNCharacterStream(final String parameterName, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNCharacterStream(parameterName, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNCharacterStream(final String parameterName, final Reader reader, final long length)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNCharacterStream(parameterName, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNClob(final String parameterName, final NClob value) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNClob(parameterName, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNClob(final String parameterName, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNClob(parameterName, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNClob(final String parameterName, final Reader reader, final long length) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNClob(parameterName, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNString(final String parameterName, final String value) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNString(parameterName, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNull(final String parameterName, final int sqlType) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNull(parameterName, sqlType);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNull(final String parameterName, final int sqlType, final String typeName) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setNull(parameterName, sqlType, typeName);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setObject(final String parameterName, final Object x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setObject(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setObject(final String parameterName, final Object x, final int targetSqlType) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setObject(parameterName, x, targetSqlType);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setObject(final String parameterName, final Object x, final int targetSqlType, final int scale)
throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setObject(parameterName, x, targetSqlType, scale);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void setObject(final String parameterName, final Object x, final SQLType targetSqlType) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setObject(parameterName, x, targetSqlType);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void setObject(final String parameterName, final Object x, final SQLType targetSqlType,
final int scaleOrLength) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setObject(parameterName, x, targetSqlType, scaleOrLength);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setRowId(final String parameterName, final RowId value) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setRowId(parameterName, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setShort(final String parameterName, final short x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setShort(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setSQLXML(final String parameterName, final SQLXML value) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setSQLXML(parameterName, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setString(final String parameterName, final String x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setString(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTime(final String parameterName, final Time x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setTime(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTime(final String parameterName, final Time x, final Calendar cal) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setTime(parameterName, x, cal);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTimestamp(final String parameterName, final Timestamp x) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setTimestamp(parameterName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTimestamp(final String parameterName, final Timestamp x, final Calendar cal) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setTimestamp(parameterName, x, cal);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setURL(final String parameterName, final URL val) throws SQLException {
checkOpen();
try {
getDelegateCallableStatement().setURL(parameterName, val);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public boolean wasNull() throws SQLException {
checkOpen();
try {
return getDelegateCallableStatement().wasNull();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
}
DelegatingConnection.java 0000664 0000000 0000000 00000103263 14473117325 0033306 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.ClientInfoStatus;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;
import org.apache.commons.dbcp2.managed.ManagedConnection;
/**
* A base delegating implementation of {@link Connection}.
*
* All of the methods from the {@link Connection} interface simply check to see that the {@link Connection} is active,
* and call the corresponding method on the "delegate" provided in my constructor.
*
*
* Extends AbandonedTrace to implement Connection tracking and logging of code which created the Connection. Tracking
* the Connection ensures that the AbandonedObjectPool can close this connection and recycle it if its pool of
* connections is nearing exhaustion and this connection's last usage is older than the removeAbandonedTimeout.
*
*
* @param
* the Connection type
*
* @since 2.0
*/
public class DelegatingConnection extends AbandonedTrace implements Connection {
private static final Map EMPTY_FAILED_PROPERTIES = Collections
.emptyMap();
/** My delegate {@link Connection}. */
private volatile C connection;
private volatile boolean closed;
private boolean cacheState = true;
private Boolean cachedAutoCommit;
private Boolean cachedReadOnly;
private String cachedCatalog;
private String cachedSchema;
private Duration defaultQueryTimeoutDuration;
/**
* Creates a wrapper for the Connection which traces this Connection in the AbandonedObjectPool.
*
* @param connection the {@link Connection} to delegate all calls to, may be null (see {@link ManagedConnection}).
*/
public DelegatingConnection(final C connection) {
this.connection = connection;
}
@Override
public void abort(final Executor executor) throws SQLException {
try {
Jdbc41Bridge.abort(connection, executor);
} catch (final SQLException e) {
handleException(e);
}
}
protected void activate() {
closed = false;
setLastUsed();
if (connection instanceof DelegatingConnection) {
((DelegatingConnection) connection).activate();
}
}
protected void checkOpen() throws SQLException {
if (closed) {
if (null != connection) {
String label;
try {
label = connection.toString();
} catch (final Exception e) {
// leave label empty
label = "";
}
throw new SQLException("Connection " + label + " is closed.");
}
throw new SQLException("Connection is null.");
}
}
/**
* Clears the cached state. Call when you know that the underlying connection may have been accessed
* directly.
*/
public void clearCachedState() {
cachedAutoCommit = null;
cachedReadOnly = null;
cachedSchema = null;
cachedCatalog = null;
if (connection instanceof DelegatingConnection) {
((DelegatingConnection) connection).clearCachedState();
}
}
@Override
public void clearWarnings() throws SQLException {
checkOpen();
try {
connection.clearWarnings();
} catch (final SQLException e) {
handleException(e);
}
}
/**
* Closes the underlying connection, and close any Statements that were not explicitly closed. Sub-classes that
* override this method must:
*
* - Call {@link #passivate()}
* - Call close (or the equivalent appropriate action) on the wrapped connection
* - Set {@code closed} to {@code false}
*
*/
@Override
public void close() throws SQLException {
if (!closed) {
closeInternal();
}
}
protected final void closeInternal() throws SQLException {
try {
passivate();
} finally {
if (connection != null) {
boolean connectionIsClosed;
try {
connectionIsClosed = connection.isClosed();
} catch (final SQLException e) {
// not sure what the state is, so assume the connection is open.
connectionIsClosed = false;
}
try {
// DBCP-512: Avoid exceptions when closing a connection in multi-threaded use case.
// Avoid closing again, which should be a no-op, but some drivers like H2 throw an exception when
// closing from multiple threads.
if (!connectionIsClosed) {
connection.close();
}
} finally {
closed = true;
}
} else {
closed = true;
}
}
}
@Override
public void commit() throws SQLException {
checkOpen();
try {
connection.commit();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
checkOpen();
try {
return connection.createArrayOf(typeName, elements);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Blob createBlob() throws SQLException {
checkOpen();
try {
return connection.createBlob();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Clob createClob() throws SQLException {
checkOpen();
try {
return connection.createClob();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public NClob createNClob() throws SQLException {
checkOpen();
try {
return connection.createNClob();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public SQLXML createSQLXML() throws SQLException {
checkOpen();
try {
return connection.createSQLXML();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public Statement createStatement() throws SQLException {
checkOpen();
try {
return init(new DelegatingStatement(this, connection.createStatement()));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
checkOpen();
try {
return init(new DelegatingStatement(this, connection.createStatement(resultSetType, resultSetConcurrency)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public Statement createStatement(final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
checkOpen();
try {
return init(new DelegatingStatement(this,
connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Struct createStruct(final String typeName, final Object[] attributes) throws SQLException {
checkOpen();
try {
return connection.createStruct(typeName, attributes);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public boolean getAutoCommit() throws SQLException {
checkOpen();
if (cacheState && cachedAutoCommit != null) {
return cachedAutoCommit;
}
try {
cachedAutoCommit = connection.getAutoCommit();
return cachedAutoCommit;
} catch (final SQLException e) {
handleException(e);
return false;
}
}
/**
* Returns the state caching flag.
*
* @return the state caching flag
*/
public boolean getCacheState() {
return cacheState;
}
@Override
public String getCatalog() throws SQLException {
checkOpen();
if (cacheState && cachedCatalog != null) {
return cachedCatalog;
}
try {
cachedCatalog = connection.getCatalog();
return cachedCatalog;
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Properties getClientInfo() throws SQLException {
checkOpen();
try {
return connection.getClientInfo();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getClientInfo(final String name) throws SQLException {
checkOpen();
try {
return connection.getClientInfo(name);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/**
* Gets the default query timeout that will be used for {@link Statement}s created from this connection.
* {@code null} means that the driver default will be used.
*
* @return query timeout limit in seconds; zero means there is no limit.
* @deprecated Use {@link #getDefaultQueryTimeoutDuration()}.
*/
@Deprecated
public Integer getDefaultQueryTimeout() {
return defaultQueryTimeoutDuration == null ? null : (int) defaultQueryTimeoutDuration.getSeconds();
}
/**
* Gets the default query timeout that will be used for {@link Statement}s created from this connection.
* {@code null} means that the driver default will be used.
*
* @return query timeout limit; zero means there is no limit.
* @since 2.10.0
*/
public Duration getDefaultQueryTimeoutDuration() {
return defaultQueryTimeoutDuration;
}
/**
* Returns my underlying {@link Connection}.
*
* @return my underlying {@link Connection}.
*/
public C getDelegate() {
return getDelegateInternal();
}
/**
* Gets the delegate connection.
*
* @return the delegate connection.
*/
protected final C getDelegateInternal() {
return connection;
}
@Override
public int getHoldability() throws SQLException {
checkOpen();
try {
return connection.getHoldability();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* If my underlying {@link Connection} is not a {@code DelegatingConnection}, returns it, otherwise recursively
* invokes this method on my delegate.
*
* Hence this method will return the first delegate that is not a {@code DelegatingConnection}, or {@code null} when
* no non-{@code DelegatingConnection} delegate can be found by traversing this chain.
*
*
* This method is useful when you may have nested {@code DelegatingConnection}s, and you want to make sure to obtain
* a "genuine" {@link Connection}.
*
*
* @return innermost delegate.
*/
public Connection getInnermostDelegate() {
return getInnermostDelegateInternal();
}
/**
* Although this method is public, it is part of the internal API and should not be used by clients. The signature
* of this method may change at any time including in ways that break backwards compatibility.
*
* @return innermost delegate.
*/
@SuppressWarnings("resource")
public final Connection getInnermostDelegateInternal() {
Connection conn = connection;
while (conn instanceof DelegatingConnection) {
conn = ((DelegatingConnection) conn).getDelegateInternal();
if (this == conn) {
return null;
}
}
return conn;
}
@Override
public DatabaseMetaData getMetaData() throws SQLException {
checkOpen();
try {
return new DelegatingDatabaseMetaData(this, connection.getMetaData());
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public int getNetworkTimeout() throws SQLException {
checkOpen();
try {
return Jdbc41Bridge.getNetworkTimeout(connection);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public String getSchema() throws SQLException {
checkOpen();
if (cacheState && cachedSchema != null) {
return cachedSchema;
}
try {
cachedSchema = Jdbc41Bridge.getSchema(connection);
return cachedSchema;
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public int getTransactionIsolation() throws SQLException {
checkOpen();
try {
return connection.getTransactionIsolation();
} catch (final SQLException e) {
handleException(e);
return -1;
}
}
@Override
public Map> getTypeMap() throws SQLException {
checkOpen();
try {
return connection.getTypeMap();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public SQLWarning getWarnings() throws SQLException {
checkOpen();
try {
return connection.getWarnings();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/**
* Handles the given exception by throwing it.
*
* @param e the exception to throw.
* @throws SQLException the exception to throw.
*/
protected void handleException(final SQLException e) throws SQLException {
throw e;
}
/**
* Handles the given {@code SQLException}.
*
* @param The throwable type.
* @param e The SQLException
* @return the given {@code SQLException}
* @since 2.7.0
*/
protected T handleExceptionNoThrow(final T e) {
return e;
}
/**
* Initializes the given statement with this connection's settings.
*
* @param The DelegatingStatement type.
* @param delegatingStatement The DelegatingStatement to initialize.
* @return The given DelegatingStatement.
* @throws SQLException if a database access error occurs, this method is called on a closed Statement.
*/
private T init(final T delegatingStatement) throws SQLException {
if (defaultQueryTimeoutDuration != null && defaultQueryTimeoutDuration.getSeconds() != delegatingStatement.getQueryTimeout()) {
delegatingStatement.setQueryTimeout((int) defaultQueryTimeoutDuration.getSeconds());
}
return delegatingStatement;
}
/**
* Compares innermost delegate to the given connection.
*
* @param c
* connection to compare innermost delegate with
* @return true if innermost delegate equals {@code c}
*/
@SuppressWarnings("resource")
public boolean innermostDelegateEquals(final Connection c) {
final Connection innerCon = getInnermostDelegateInternal();
if (innerCon == null) {
return c == null;
}
return innerCon.equals(c);
}
@Override
public boolean isClosed() throws SQLException {
return closed || connection == null || connection.isClosed();
}
protected boolean isClosedInternal() {
return closed;
}
@Override
public boolean isReadOnly() throws SQLException {
checkOpen();
if (cacheState && cachedReadOnly != null) {
return cachedReadOnly;
}
try {
cachedReadOnly = connection.isReadOnly();
return cachedReadOnly;
} catch (final SQLException e) {
handleException(e);
return false;
}
}
/**
* Tests if the connection has not been closed and is still valid.
*
* @param timeout The duration to wait for the database operation used to validate the connection to complete.
* @return See {@link Connection#isValid(int)}.
* @throws SQLException See {@link Connection#isValid(int)}.
* @see Connection#isValid(int)
* @since 2.10.0
*/
public boolean isValid(final Duration timeout) throws SQLException {
if (isClosed()) {
return false;
}
try {
return connection.isValid((int) timeout.getSeconds());
} catch (final SQLException e) {
handleException(e);
return false;
}
}
/**
* @deprecated Use {@link #isValid(Duration)}.
*/
@Override
@Deprecated
public boolean isValid(final int timeoutSeconds) throws SQLException {
return isValid(Duration.ofSeconds(timeoutSeconds));
}
@Override
public boolean isWrapperFor(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
}
if (iface.isAssignableFrom(connection.getClass())) {
return true;
}
return connection.isWrapperFor(iface);
}
@Override
public String nativeSQL(final String sql) throws SQLException {
checkOpen();
try {
return connection.nativeSQL(sql);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
protected void passivate() throws SQLException {
// The JDBC specification requires that a Connection close any open
// Statements when it is closed.
// DBCP-288. Not all the traced objects will be statements
final List traceList = getTrace();
if (!Utils.isEmpty(traceList)) {
final List thrownList = new ArrayList<>();
traceList.forEach(trace -> trace.close(thrownList::add));
clearTrace();
if (!thrownList.isEmpty()) {
throw new SQLExceptionList(thrownList);
}
}
setLastUsed(Instant.EPOCH);
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public CallableStatement prepareCall(final String sql) throws SQLException {
checkOpen();
try {
return init(new DelegatingCallableStatement(this, connection.prepareCall(sql)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
checkOpen();
try {
return init(new DelegatingCallableStatement(this,
connection.prepareCall(sql, resultSetType, resultSetConcurrency)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
checkOpen();
try {
return init(new DelegatingCallableStatement(this,
connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public PreparedStatement prepareStatement(final String sql) throws SQLException {
checkOpen();
try {
return init(new DelegatingPreparedStatement(this, connection.prepareStatement(sql)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
try {
return init(new DelegatingPreparedStatement(this, connection.prepareStatement(sql, autoGeneratedKeys)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
checkOpen();
try {
return init(new DelegatingPreparedStatement(this,
connection.prepareStatement(sql, resultSetType, resultSetConcurrency)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
checkOpen();
try {
return init(new DelegatingPreparedStatement(this,
connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
checkOpen();
try {
return init(new DelegatingPreparedStatement(this, connection.prepareStatement(sql, columnIndexes)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
checkOpen();
try {
return init(new DelegatingPreparedStatement(this, connection.prepareStatement(sql, columnNames)));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
checkOpen();
try {
connection.releaseSavepoint(savepoint);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void rollback() throws SQLException {
checkOpen();
try {
connection.rollback();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void rollback(final Savepoint savepoint) throws SQLException {
checkOpen();
try {
connection.rollback(savepoint);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setAutoCommit(final boolean autoCommit) throws SQLException {
checkOpen();
try {
connection.setAutoCommit(autoCommit);
if (cacheState) {
cachedAutoCommit = connection.getAutoCommit();
}
} catch (final SQLException e) {
cachedAutoCommit = null;
handleException(e);
}
}
/**
* Sets the state caching flag.
*
* @param cacheState
* The new value for the state caching flag
*/
public void setCacheState(final boolean cacheState) {
this.cacheState = cacheState;
}
@Override
public void setCatalog(final String catalog) throws SQLException {
checkOpen();
try {
connection.setCatalog(catalog);
if (cacheState) {
cachedCatalog = connection.getCatalog();
}
} catch (final SQLException e) {
cachedCatalog = null;
handleException(e);
}
}
@Override
public void setClientInfo(final Properties properties) throws SQLClientInfoException {
try {
checkOpen();
connection.setClientInfo(properties);
} catch (final SQLClientInfoException e) {
throw e;
} catch (final SQLException e) {
throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
}
}
@Override
public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
try {
checkOpen();
connection.setClientInfo(name, value);
} catch (final SQLClientInfoException e) {
throw e;
} catch (final SQLException e) {
throw new SQLClientInfoException("Connection is closed.", EMPTY_FAILED_PROPERTIES, e);
}
}
protected void setClosedInternal(final boolean closed) {
this.closed = closed;
}
/**
* Sets the default query timeout that will be used for {@link Statement}s created from this connection.
* {@code null} means that the driver default will be used.
*
* @param defaultQueryTimeoutDuration
* the new query timeout limit Duration; zero means there is no limit.
* @since 2.10.0
*/
public void setDefaultQueryTimeout(final Duration defaultQueryTimeoutDuration) {
this.defaultQueryTimeoutDuration = defaultQueryTimeoutDuration;
}
/**
* Sets the default query timeout that will be used for {@link Statement}s created from this connection.
* {@code null} means that the driver default will be used.
*
* @param defaultQueryTimeoutSeconds
* the new query timeout limit in seconds; zero means there is no limit.
* @deprecated Use {@link #setDefaultQueryTimeout(Duration)}.
*/
@Deprecated
public void setDefaultQueryTimeout(final Integer defaultQueryTimeoutSeconds) {
this.defaultQueryTimeoutDuration = defaultQueryTimeoutSeconds == null ? null : Duration.ofSeconds(defaultQueryTimeoutSeconds);
}
/**
* Sets my delegate.
*
* @param connection
* my delegate, may be null.
*/
public void setDelegate(final C connection) {
this.connection = connection;
}
@Override
public void setHoldability(final int holdability) throws SQLException {
checkOpen();
try {
connection.setHoldability(holdability);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNetworkTimeout(final Executor executor, final int milliseconds) throws SQLException {
checkOpen();
try {
Jdbc41Bridge.setNetworkTimeout(connection, executor, milliseconds);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setReadOnly(final boolean readOnly) throws SQLException {
checkOpen();
try {
connection.setReadOnly(readOnly);
if (cacheState) {
cachedReadOnly = connection.isReadOnly();
}
} catch (final SQLException e) {
cachedReadOnly = null;
handleException(e);
}
}
@Override
public Savepoint setSavepoint() throws SQLException {
checkOpen();
try {
return connection.setSavepoint();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Savepoint setSavepoint(final String name) throws SQLException {
checkOpen();
try {
return connection.setSavepoint(name);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public void setSchema(final String schema) throws SQLException {
checkOpen();
try {
Jdbc41Bridge.setSchema(connection, schema);
if (cacheState) {
cachedSchema = connection.getSchema();
}
} catch (final SQLException e) {
cachedSchema = null;
handleException(e);
}
}
@Override
public void setTransactionIsolation(final int level) throws SQLException {
checkOpen();
try {
connection.setTransactionIsolation(level);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTypeMap(final Map> map) throws SQLException {
checkOpen();
try {
connection.setTypeMap(map);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* Returns a string representation of the metadata associated with the innermost delegate connection.
*/
@SuppressWarnings("resource")
@Override
public synchronized String toString() {
String str = null;
final Connection conn = this.getInnermostDelegateInternal();
if (conn != null) {
try {
if (conn.isClosed()) {
str = "connection is closed";
} else {
final StringBuilder sb = new StringBuilder();
sb.append(hashCode());
final DatabaseMetaData meta = conn.getMetaData();
if (meta != null) {
sb.append(", URL=");
sb.append(meta.getURL());
sb.append(", ");
sb.append(meta.getDriverName());
str = sb.toString();
}
}
} catch (final SQLException ignored) {
// Ignore
}
}
return str != null ? str : super.toString();
}
@Override
public T unwrap(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
}
if (iface.isAssignableFrom(connection.getClass())) {
return iface.cast(connection);
}
return connection.unwrap(iface);
}
}
DelegatingDatabaseMetaData.java 0000664 0000000 0000000 00000161453 14473117325 0034321 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.RowIdLifetime;
import java.sql.SQLException;
/**
*
* A base delegating implementation of {@link DatabaseMetaData}.
*
*
* Methods that create {@link ResultSet} objects are wrapped to create {@link DelegatingResultSet} objects and the
* remaining methods simply call the corresponding method on the "delegate" provided in the constructor.
*
*
* @since 2.0
*/
public class DelegatingDatabaseMetaData implements DatabaseMetaData {
/** My delegate {@link DatabaseMetaData} */
private final DatabaseMetaData databaseMetaData;
/** The connection that created me. **/
private final DelegatingConnection connection;
/**
* Constructs a new instance for the given delegating connection and database meta data.
*
* @param connection
* the delegating connection
* @param databaseMetaData
* the database meta data
*/
public DelegatingDatabaseMetaData(final DelegatingConnection connection,
final DatabaseMetaData databaseMetaData) {
this.connection = connection;
this.databaseMetaData = databaseMetaData;
}
@Override
public boolean allProceduresAreCallable() throws SQLException {
try {
return databaseMetaData.allProceduresAreCallable();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean allTablesAreSelectable() throws SQLException {
try {
return databaseMetaData.allTablesAreSelectable();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
try {
return databaseMetaData.autoCommitFailureClosesAllResultSets();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
try {
return databaseMetaData.dataDefinitionCausesTransactionCommit();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
try {
return databaseMetaData.dataDefinitionIgnoredInTransactions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean deletesAreDetected(final int type) throws SQLException {
try {
return databaseMetaData.deletesAreDetected(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
try {
return databaseMetaData.doesMaxRowSizeIncludeBlobs();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean generatedKeyAlwaysReturned() throws SQLException {
connection.checkOpen();
try {
return Jdbc41Bridge.generatedKeyAlwaysReturned(databaseMetaData);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public ResultSet getAttributes(final String catalog, final String schemaPattern, final String typeNamePattern,
final String attributeNamePattern) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getBestRowIdentifier(final String catalog, final String schema, final String table,
final int scope, final boolean nullable) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getBestRowIdentifier(catalog, schema, table, scope, nullable));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getCatalogs() throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCatalogs());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getCatalogSeparator() throws SQLException {
try {
return databaseMetaData.getCatalogSeparator();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getCatalogTerm() throws SQLException {
try {
return databaseMetaData.getCatalogTerm();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getClientInfoProperties() throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getClientInfoProperties());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getColumnPrivileges(final String catalog, final String schema, final String table,
final String columnNamePattern) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getColumnPrivileges(catalog, schema, table, columnNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getColumns(final String catalog, final String schemaPattern, final String tableNamePattern,
final String columnNamePattern) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public Connection getConnection() throws SQLException {
return connection;
}
@Override
public ResultSet getCrossReference(final String parentCatalog, final String parentSchema, final String parentTable,
final String foreignCatalog, final String foreignSchema, final String foreignTable) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getCrossReference(parentCatalog,
parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public int getDatabaseMajorVersion() throws SQLException {
try {
return databaseMetaData.getDatabaseMajorVersion();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getDatabaseMinorVersion() throws SQLException {
try {
return databaseMetaData.getDatabaseMinorVersion();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public String getDatabaseProductName() throws SQLException {
try {
return databaseMetaData.getDatabaseProductName();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getDatabaseProductVersion() throws SQLException {
try {
return databaseMetaData.getDatabaseProductVersion();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public int getDefaultTransactionIsolation() throws SQLException {
try {
return databaseMetaData.getDefaultTransactionIsolation();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* Gets the underlying database meta data.
*
* @return The underlying database meta data.
*/
public DatabaseMetaData getDelegate() {
return databaseMetaData;
}
@Override
public int getDriverMajorVersion() {
return databaseMetaData.getDriverMajorVersion();
}
@Override
public int getDriverMinorVersion() {
return databaseMetaData.getDriverMinorVersion();
}
@Override
public String getDriverName() throws SQLException {
try {
return databaseMetaData.getDriverName();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getDriverVersion() throws SQLException {
try {
return databaseMetaData.getDriverVersion();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getExportedKeys(final String catalog, final String schema, final String table)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getExportedKeys(catalog, schema, table));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getExtraNameCharacters() throws SQLException {
try {
return databaseMetaData.getExtraNameCharacters();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getFunctionColumns(final String catalog, final String schemaPattern,
final String functionNamePattern, final String columnNamePattern) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getFunctionColumns(catalog,
schemaPattern, functionNamePattern, columnNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getFunctions(final String catalog, final String schemaPattern, final String functionNamePattern)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getFunctions(catalog, schemaPattern, functionNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getIdentifierQuoteString() throws SQLException {
try {
return databaseMetaData.getIdentifierQuoteString();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getImportedKeys(final String catalog, final String schema, final String table)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getImportedKeys(catalog, schema, table));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getIndexInfo(final String catalog, final String schema, final String table, final boolean unique,
final boolean approximate) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getIndexInfo(catalog, schema, table, unique, approximate));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
/**
* If my underlying {@link ResultSet} is not a {@code DelegatingResultSet}, returns it, otherwise recursively
* invokes this method on my delegate.
*
* Hence this method will return the first delegate that is not a {@code DelegatingResultSet}, or {@code null} when
* no non-{@code DelegatingResultSet} delegate can be found by traversing this chain.
*
*
* This method is useful when you may have nested {@code DelegatingResultSet}s, and you want to make sure to obtain
* a "genuine" {@link ResultSet}.
*
*
* @return the innermost database meta data.
*/
public DatabaseMetaData getInnermostDelegate() {
DatabaseMetaData m = databaseMetaData;
while (m instanceof DelegatingDatabaseMetaData) {
m = ((DelegatingDatabaseMetaData) m).getDelegate();
if (this == m) {
return null;
}
}
return m;
}
@Override
public int getJDBCMajorVersion() throws SQLException {
try {
return databaseMetaData.getJDBCMajorVersion();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getJDBCMinorVersion() throws SQLException {
try {
return databaseMetaData.getJDBCMinorVersion();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxBinaryLiteralLength() throws SQLException {
try {
return databaseMetaData.getMaxBinaryLiteralLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxCatalogNameLength() throws SQLException {
try {
return databaseMetaData.getMaxCatalogNameLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxCharLiteralLength() throws SQLException {
try {
return databaseMetaData.getMaxCharLiteralLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxColumnNameLength() throws SQLException {
try {
return databaseMetaData.getMaxColumnNameLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxColumnsInGroupBy() throws SQLException {
try {
return databaseMetaData.getMaxColumnsInGroupBy();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxColumnsInIndex() throws SQLException {
try {
return databaseMetaData.getMaxColumnsInIndex();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxColumnsInOrderBy() throws SQLException {
try {
return databaseMetaData.getMaxColumnsInOrderBy();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxColumnsInSelect() throws SQLException {
try {
return databaseMetaData.getMaxColumnsInSelect();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxColumnsInTable() throws SQLException {
try {
return databaseMetaData.getMaxColumnsInTable();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxConnections() throws SQLException {
try {
return databaseMetaData.getMaxConnections();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxCursorNameLength() throws SQLException {
try {
return databaseMetaData.getMaxCursorNameLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxIndexLength() throws SQLException {
try {
return databaseMetaData.getMaxIndexLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* @since 2.5.0
*/
@Override
public long getMaxLogicalLobSize() throws SQLException {
try {
return databaseMetaData.getMaxLogicalLobSize();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxProcedureNameLength() throws SQLException {
try {
return databaseMetaData.getMaxProcedureNameLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxRowSize() throws SQLException {
try {
return databaseMetaData.getMaxRowSize();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxSchemaNameLength() throws SQLException {
try {
return databaseMetaData.getMaxSchemaNameLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxStatementLength() throws SQLException {
try {
return databaseMetaData.getMaxStatementLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxStatements() throws SQLException {
try {
return databaseMetaData.getMaxStatements();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxTableNameLength() throws SQLException {
try {
return databaseMetaData.getMaxTableNameLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxTablesInSelect() throws SQLException {
try {
return databaseMetaData.getMaxTablesInSelect();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxUserNameLength() throws SQLException {
try {
return databaseMetaData.getMaxUserNameLength();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public String getNumericFunctions() throws SQLException {
try {
return databaseMetaData.getNumericFunctions();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getPrimaryKeys(final String catalog, final String schema, final String table) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getPrimaryKeys(catalog, schema, table));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getProcedureColumns(final String catalog, final String schemaPattern,
final String procedureNamePattern, final String columnNamePattern) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getProcedureColumns(catalog,
schemaPattern, procedureNamePattern, columnNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getProcedures(final String catalog, final String schemaPattern, final String procedureNamePattern)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getProcedures(catalog, schemaPattern, procedureNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getProcedureTerm() throws SQLException {
try {
return databaseMetaData.getProcedureTerm();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getPseudoColumns(final String catalog, final String schemaPattern, final String tableNamePattern,
final String columnNamePattern) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, Jdbc41Bridge.getPseudoColumns(databaseMetaData,
catalog, schemaPattern, tableNamePattern, columnNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public int getResultSetHoldability() throws SQLException {
try {
return databaseMetaData.getResultSetHoldability();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public RowIdLifetime getRowIdLifetime() throws SQLException {
try {
return databaseMetaData.getRowIdLifetime();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getSchemas() throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getSchemas(final String catalog, final String schemaPattern) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getSchemas(catalog, schemaPattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getSchemaTerm() throws SQLException {
try {
return databaseMetaData.getSchemaTerm();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getSearchStringEscape() throws SQLException {
try {
return databaseMetaData.getSearchStringEscape();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getSQLKeywords() throws SQLException {
try {
return databaseMetaData.getSQLKeywords();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public int getSQLStateType() throws SQLException {
try {
return databaseMetaData.getSQLStateType();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public String getStringFunctions() throws SQLException {
try {
return databaseMetaData.getStringFunctions();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getSuperTables(final String catalog, final String schemaPattern, final String tableNamePattern)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getSuperTables(catalog, schemaPattern, tableNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getSuperTypes(final String catalog, final String schemaPattern, final String typeNamePattern)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getSuperTypes(catalog, schemaPattern, typeNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getSystemFunctions() throws SQLException {
try {
return databaseMetaData.getSystemFunctions();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getTablePrivileges(final String catalog, final String schemaPattern, final String tableNamePattern)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getTablePrivileges(catalog, schemaPattern, tableNamePattern));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getTables(final String catalog, final String schemaPattern, final String tableNamePattern,
final String[] types) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getTables(catalog, schemaPattern, tableNamePattern, types));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getTableTypes() throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTableTypes());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getTimeDateFunctions() throws SQLException {
try {
return databaseMetaData.getTimeDateFunctions();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getTypeInfo() throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection, databaseMetaData.getTypeInfo());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getUDTs(final String catalog, final String schemaPattern, final String typeNamePattern,
final int[] types) throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getUDTs(catalog, schemaPattern, typeNamePattern, types));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getURL() throws SQLException {
try {
return databaseMetaData.getURL();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public String getUserName() throws SQLException {
try {
return databaseMetaData.getUserName();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public ResultSet getVersionColumns(final String catalog, final String schema, final String table)
throws SQLException {
connection.checkOpen();
try {
return DelegatingResultSet.wrapResultSet(connection,
databaseMetaData.getVersionColumns(catalog, schema, table));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
protected void handleException(final SQLException e) throws SQLException {
if (connection == null) {
throw e;
}
connection.handleException(e);
}
@Override
public boolean insertsAreDetected(final int type) throws SQLException {
try {
return databaseMetaData.insertsAreDetected(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isCatalogAtStart() throws SQLException {
try {
return databaseMetaData.isCatalogAtStart();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isReadOnly() throws SQLException {
try {
return databaseMetaData.isReadOnly();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isWrapperFor(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
}
if (iface.isAssignableFrom(databaseMetaData.getClass())) {
return true;
}
return databaseMetaData.isWrapperFor(iface);
}
@Override
public boolean locatorsUpdateCopy() throws SQLException {
try {
return databaseMetaData.locatorsUpdateCopy();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean nullPlusNonNullIsNull() throws SQLException {
try {
return databaseMetaData.nullPlusNonNullIsNull();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean nullsAreSortedAtEnd() throws SQLException {
try {
return databaseMetaData.nullsAreSortedAtEnd();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean nullsAreSortedAtStart() throws SQLException {
try {
return databaseMetaData.nullsAreSortedAtStart();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean nullsAreSortedHigh() throws SQLException {
try {
return databaseMetaData.nullsAreSortedHigh();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean nullsAreSortedLow() throws SQLException {
try {
return databaseMetaData.nullsAreSortedLow();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean othersDeletesAreVisible(final int type) throws SQLException {
try {
return databaseMetaData.othersDeletesAreVisible(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean othersInsertsAreVisible(final int type) throws SQLException {
try {
return databaseMetaData.othersInsertsAreVisible(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean othersUpdatesAreVisible(final int type) throws SQLException {
try {
return databaseMetaData.othersUpdatesAreVisible(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean ownDeletesAreVisible(final int type) throws SQLException {
try {
return databaseMetaData.ownDeletesAreVisible(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean ownInsertsAreVisible(final int type) throws SQLException {
try {
return databaseMetaData.ownInsertsAreVisible(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean ownUpdatesAreVisible(final int type) throws SQLException {
try {
return databaseMetaData.ownUpdatesAreVisible(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean storesLowerCaseIdentifiers() throws SQLException {
try {
return databaseMetaData.storesLowerCaseIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
try {
return databaseMetaData.storesLowerCaseQuotedIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean storesMixedCaseIdentifiers() throws SQLException {
try {
return databaseMetaData.storesMixedCaseIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
try {
return databaseMetaData.storesMixedCaseQuotedIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean storesUpperCaseIdentifiers() throws SQLException {
try {
return databaseMetaData.storesUpperCaseIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
try {
return databaseMetaData.storesUpperCaseQuotedIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsAlterTableWithAddColumn() throws SQLException {
try {
return databaseMetaData.supportsAlterTableWithAddColumn();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsAlterTableWithDropColumn() throws SQLException {
try {
return databaseMetaData.supportsAlterTableWithDropColumn();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsANSI92EntryLevelSQL() throws SQLException {
try {
return databaseMetaData.supportsANSI92EntryLevelSQL();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsANSI92FullSQL() throws SQLException {
try {
return databaseMetaData.supportsANSI92FullSQL();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsANSI92IntermediateSQL() throws SQLException {
try {
return databaseMetaData.supportsANSI92IntermediateSQL();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsBatchUpdates() throws SQLException {
try {
return databaseMetaData.supportsBatchUpdates();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsCatalogsInDataManipulation() throws SQLException {
try {
return databaseMetaData.supportsCatalogsInDataManipulation();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
try {
return databaseMetaData.supportsCatalogsInIndexDefinitions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
try {
return databaseMetaData.supportsCatalogsInPrivilegeDefinitions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsCatalogsInProcedureCalls() throws SQLException {
try {
return databaseMetaData.supportsCatalogsInProcedureCalls();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsCatalogsInTableDefinitions() throws SQLException {
try {
return databaseMetaData.supportsCatalogsInTableDefinitions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsColumnAliasing() throws SQLException {
try {
return databaseMetaData.supportsColumnAliasing();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsConvert() throws SQLException {
try {
return databaseMetaData.supportsConvert();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsConvert(final int fromType, final int toType) throws SQLException {
try {
return databaseMetaData.supportsConvert(fromType, toType);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsCoreSQLGrammar() throws SQLException {
try {
return databaseMetaData.supportsCoreSQLGrammar();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsCorrelatedSubqueries() throws SQLException {
try {
return databaseMetaData.supportsCorrelatedSubqueries();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
try {
return databaseMetaData.supportsDataDefinitionAndDataManipulationTransactions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
try {
return databaseMetaData.supportsDataManipulationTransactionsOnly();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsDifferentTableCorrelationNames() throws SQLException {
try {
return databaseMetaData.supportsDifferentTableCorrelationNames();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsExpressionsInOrderBy() throws SQLException {
try {
return databaseMetaData.supportsExpressionsInOrderBy();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsExtendedSQLGrammar() throws SQLException {
try {
return databaseMetaData.supportsExtendedSQLGrammar();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsFullOuterJoins() throws SQLException {
try {
return databaseMetaData.supportsFullOuterJoins();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsGetGeneratedKeys() throws SQLException {
try {
return databaseMetaData.supportsGetGeneratedKeys();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsGroupBy() throws SQLException {
try {
return databaseMetaData.supportsGroupBy();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsGroupByBeyondSelect() throws SQLException {
try {
return databaseMetaData.supportsGroupByBeyondSelect();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsGroupByUnrelated() throws SQLException {
try {
return databaseMetaData.supportsGroupByUnrelated();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsIntegrityEnhancementFacility() throws SQLException {
try {
return databaseMetaData.supportsIntegrityEnhancementFacility();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsLikeEscapeClause() throws SQLException {
try {
return databaseMetaData.supportsLikeEscapeClause();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsLimitedOuterJoins() throws SQLException {
try {
return databaseMetaData.supportsLimitedOuterJoins();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsMinimumSQLGrammar() throws SQLException {
try {
return databaseMetaData.supportsMinimumSQLGrammar();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsMixedCaseIdentifiers() throws SQLException {
try {
return databaseMetaData.supportsMixedCaseIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
try {
return databaseMetaData.supportsMixedCaseQuotedIdentifiers();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsMultipleOpenResults() throws SQLException {
try {
return databaseMetaData.supportsMultipleOpenResults();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsMultipleResultSets() throws SQLException {
try {
return databaseMetaData.supportsMultipleResultSets();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsMultipleTransactions() throws SQLException {
try {
return databaseMetaData.supportsMultipleTransactions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsNamedParameters() throws SQLException {
try {
return databaseMetaData.supportsNamedParameters();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsNonNullableColumns() throws SQLException {
try {
return databaseMetaData.supportsNonNullableColumns();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
try {
return databaseMetaData.supportsOpenCursorsAcrossCommit();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
try {
return databaseMetaData.supportsOpenCursorsAcrossRollback();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
try {
return databaseMetaData.supportsOpenStatementsAcrossCommit();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
try {
return databaseMetaData.supportsOpenStatementsAcrossRollback();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsOrderByUnrelated() throws SQLException {
try {
return databaseMetaData.supportsOrderByUnrelated();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsOuterJoins() throws SQLException {
try {
return databaseMetaData.supportsOuterJoins();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsPositionedDelete() throws SQLException {
try {
return databaseMetaData.supportsPositionedDelete();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsPositionedUpdate() throws SQLException {
try {
return databaseMetaData.supportsPositionedUpdate();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
/**
* @since 2.5.0
*/
@Override
public boolean supportsRefCursors() throws SQLException {
try {
return databaseMetaData.supportsRefCursors();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsResultSetConcurrency(final int type, final int concurrency) throws SQLException {
try {
return databaseMetaData.supportsResultSetConcurrency(type, concurrency);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsResultSetHoldability(final int holdability) throws SQLException {
try {
return databaseMetaData.supportsResultSetHoldability(holdability);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsResultSetType(final int type) throws SQLException {
try {
return databaseMetaData.supportsResultSetType(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSavepoints() throws SQLException {
try {
return databaseMetaData.supportsSavepoints();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSchemasInDataManipulation() throws SQLException {
try {
return databaseMetaData.supportsSchemasInDataManipulation();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSchemasInIndexDefinitions() throws SQLException {
try {
return databaseMetaData.supportsSchemasInIndexDefinitions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
try {
return databaseMetaData.supportsSchemasInPrivilegeDefinitions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSchemasInProcedureCalls() throws SQLException {
try {
return databaseMetaData.supportsSchemasInProcedureCalls();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSchemasInTableDefinitions() throws SQLException {
try {
return databaseMetaData.supportsSchemasInTableDefinitions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSelectForUpdate() throws SQLException {
try {
return databaseMetaData.supportsSelectForUpdate();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsStatementPooling() throws SQLException {
try {
return databaseMetaData.supportsStatementPooling();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
try {
return databaseMetaData.supportsStoredFunctionsUsingCallSyntax();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsStoredProcedures() throws SQLException {
try {
return databaseMetaData.supportsStoredProcedures();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSubqueriesInComparisons() throws SQLException {
try {
return databaseMetaData.supportsSubqueriesInComparisons();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSubqueriesInExists() throws SQLException {
try {
return databaseMetaData.supportsSubqueriesInExists();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSubqueriesInIns() throws SQLException {
try {
return databaseMetaData.supportsSubqueriesInIns();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsSubqueriesInQuantifieds() throws SQLException {
try {
return databaseMetaData.supportsSubqueriesInQuantifieds();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsTableCorrelationNames() throws SQLException {
try {
return databaseMetaData.supportsTableCorrelationNames();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsTransactionIsolationLevel(final int level) throws SQLException {
try {
return databaseMetaData.supportsTransactionIsolationLevel(level);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsTransactions() throws SQLException {
try {
return databaseMetaData.supportsTransactions();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsUnion() throws SQLException {
try {
return databaseMetaData.supportsUnion();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean supportsUnionAll() throws SQLException {
try {
return databaseMetaData.supportsUnionAll();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public T unwrap(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
}
if (iface.isAssignableFrom(databaseMetaData.getClass())) {
return iface.cast(databaseMetaData);
}
return databaseMetaData.unwrap(iface);
}
@Override
public boolean updatesAreDetected(final int type) throws SQLException {
try {
return databaseMetaData.updatesAreDetected(type);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean usesLocalFilePerTable() throws SQLException {
try {
return databaseMetaData.usesLocalFilePerTable();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean usesLocalFiles() throws SQLException {
try {
return databaseMetaData.usesLocalFiles();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
}
DelegatingPreparedStatement.java 0000664 0000000 0000000 00000055774 14473117325 0034653 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLType;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
/**
* A base delegating implementation of {@link PreparedStatement}.
*
* All of the methods from the {@link PreparedStatement} interface simply check to see that the
* {@link PreparedStatement} is active, and call the corresponding method on the "delegate" provided in my constructor.
*
* Extends AbandonedTrace to implement Statement tracking and logging of code which created the Statement. Tracking the
* Statement ensures that the Connection which created it can close any open Statement's on Connection close.
*
* @since 2.0
*/
public class DelegatingPreparedStatement extends DelegatingStatement implements PreparedStatement {
/**
* Create a wrapper for the Statement which traces this Statement to the Connection which created it and the code
* which created it.
*
* @param statement
* the {@link PreparedStatement} to delegate all calls to.
* @param connection
* the {@link DelegatingConnection} that created this statement.
*/
public DelegatingPreparedStatement(final DelegatingConnection connection, final PreparedStatement statement) {
super(connection, statement);
}
@Override
public void addBatch() throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().addBatch();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void clearParameters() throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().clearParameters();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public boolean execute() throws SQLException {
checkOpen();
if (getConnectionInternal() != null) {
getConnectionInternal().setLastUsed();
}
try {
return getDelegatePreparedStatement().execute();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
/**
* @since 2.5.0
*/
@Override
public long executeLargeUpdate() throws SQLException {
checkOpen();
try {
return getDelegatePreparedStatement().executeLargeUpdate();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public ResultSet executeQuery() throws SQLException {
checkOpen();
if (getConnectionInternal() != null) {
getConnectionInternal().setLastUsed();
}
try {
return DelegatingResultSet.wrapResultSet(this, getDelegatePreparedStatement().executeQuery());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public int executeUpdate() throws SQLException {
checkOpen();
if (getConnectionInternal() != null) {
getConnectionInternal().setLastUsed();
}
try {
return getDelegatePreparedStatement().executeUpdate();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
private PreparedStatement getDelegatePreparedStatement() {
return (PreparedStatement) getDelegate();
}
@Override
public ResultSetMetaData getMetaData() throws SQLException {
checkOpen();
try {
return getDelegatePreparedStatement().getMetaData();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public java.sql.ParameterMetaData getParameterMetaData() throws SQLException {
checkOpen();
try {
return getDelegatePreparedStatement().getParameterMetaData();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public void setArray(final int i, final Array x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setArray(i, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setAsciiStream(final int parameterIndex, final InputStream inputStream) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setAsciiStream(parameterIndex, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setAsciiStream(final int parameterIndex, final InputStream x, final int length) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setAsciiStream(parameterIndex, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setAsciiStream(final int parameterIndex, final InputStream inputStream, final long length)
throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setAsciiStream(parameterIndex, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBigDecimal(final int parameterIndex, final BigDecimal x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBigDecimal(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBinaryStream(final int parameterIndex, final InputStream inputStream) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBinaryStream(parameterIndex, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBinaryStream(final int parameterIndex, final InputStream x, final int length) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBinaryStream(parameterIndex, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBinaryStream(final int parameterIndex, final InputStream inputStream, final long length)
throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBinaryStream(parameterIndex, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBlob(final int i, final Blob x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBlob(i, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBlob(final int parameterIndex, final InputStream inputStream) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBlob(parameterIndex, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBlob(final int parameterIndex, final InputStream inputStream, final long length)
throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBlob(parameterIndex, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBoolean(final int parameterIndex, final boolean x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBoolean(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setByte(final int parameterIndex, final byte x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setByte(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setBytes(final int parameterIndex, final byte[] x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setBytes(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setCharacterStream(final int parameterIndex, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setCharacterStream(parameterIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setCharacterStream(final int parameterIndex, final Reader reader, final int length)
throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setCharacterStream(parameterIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setCharacterStream(final int parameterIndex, final Reader reader, final long length)
throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setCharacterStream(parameterIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setClob(final int i, final Clob x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setClob(i, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setClob(final int parameterIndex, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setClob(parameterIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setClob(final int parameterIndex, final Reader reader, final long length) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setClob(parameterIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setDate(final int parameterIndex, final Date x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setDate(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setDate(final int parameterIndex, final Date x, final Calendar cal) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setDate(parameterIndex, x, cal);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setDouble(final int parameterIndex, final double x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setDouble(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setFloat(final int parameterIndex, final float x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setFloat(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setInt(final int parameterIndex, final int x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setInt(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setLong(final int parameterIndex, final long x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setLong(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNCharacterStream(final int parameterIndex, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNCharacterStream(parameterIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNCharacterStream(final int parameterIndex, final Reader value, final long length)
throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNCharacterStream(parameterIndex, value, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNClob(final int parameterIndex, final NClob value) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNClob(parameterIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNClob(final int parameterIndex, final Reader reader) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNClob(parameterIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNClob(final int parameterIndex, final Reader reader, final long length) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNClob(parameterIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNString(final int parameterIndex, final String value) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNString(parameterIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNull(final int parameterIndex, final int sqlType) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNull(parameterIndex, sqlType);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setNull(final int paramIndex, final int sqlType, final String typeName) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setNull(paramIndex, sqlType, typeName);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setObject(final int parameterIndex, final Object x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setObject(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setObject(final int parameterIndex, final Object x, final int targetSqlType) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setObject(final int parameterIndex, final Object x, final int targetSqlType, final int scale)
throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType, scale);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void setObject(final int parameterIndex, final Object x, final SQLType targetSqlType) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void setObject(final int parameterIndex, final Object x, final SQLType targetSqlType, final int scaleOrLength) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType, scaleOrLength);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setRef(final int i, final Ref x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setRef(i, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setRowId(final int parameterIndex, final RowId value) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setRowId(parameterIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setShort(final int parameterIndex, final short x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setShort(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setSQLXML(final int parameterIndex, final SQLXML value) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setSQLXML(parameterIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setString(final int parameterIndex, final String x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setString(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTime(final int parameterIndex, final Time x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setTime(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTime(final int parameterIndex, final Time x, final Calendar cal) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setTime(parameterIndex, x, cal);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTimestamp(final int parameterIndex, final Timestamp x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setTimestamp(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setTimestamp(final int parameterIndex, final Timestamp x, final Calendar cal) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setTimestamp(parameterIndex, x, cal);
} catch (final SQLException e) {
handleException(e);
}
}
/** @deprecated Use setAsciiStream(), setCharacterStream() or setNCharacterStream() */
@Deprecated
@Override
public void setUnicodeStream(final int parameterIndex, final InputStream x, final int length) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setUnicodeStream(parameterIndex, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setURL(final int parameterIndex, final java.net.URL x) throws SQLException {
checkOpen();
try {
getDelegatePreparedStatement().setURL(parameterIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* Returns a String representation of this object.
*
* @return String
*/
@SuppressWarnings("resource")
@Override
public synchronized String toString() {
final Statement statement = getDelegate();
return statement == null ? "NULL" : statement.toString();
}
protected void prepareToReturn() throws SQLException {
setClosedInternal(true);
removeThisTrace(getConnectionInternal());
// The JDBC spec requires that a statement close any open
// ResultSet's when it is closed.
// FIXME The PreparedStatement we're wrapping should handle this for us.
// See DBCP-10 for what could happen when ResultSets are closed twice.
final List traceList = getTrace();
if (traceList != null) {
final List thrownList = new ArrayList<>();
traceList.forEach(trace -> trace.close(thrownList::add));
clearTrace();
if (!thrownList.isEmpty()) {
throw new SQLExceptionList(thrownList);
}
}
super.passivate();
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java0000664 0000000 0000000 00000163665 14473117325 0033234 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.NClob;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLType;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Map;
/**
* A base delegating implementation of {@link ResultSet}.
*
* All of the methods from the {@link ResultSet} interface simply call the corresponding method on the "delegate"
* provided in my constructor.
*
*
* Extends AbandonedTrace to implement result set tracking and logging of code which created the ResultSet. Tracking the
* ResultSet ensures that the Statement which created it can close any open ResultSet's on Statement close.
*
*
* @since 2.0
*/
public final class DelegatingResultSet extends AbandonedTrace implements ResultSet {
/**
* Wraps the given result set in a delegate.
*
* @param connection
* The Connection which created the ResultSet.
* @param resultSet
* The ResultSet to wrap.
* @return a new delegate.
*/
public static ResultSet wrapResultSet(final Connection connection, final ResultSet resultSet) {
if (null == resultSet) {
return null;
}
return new DelegatingResultSet(connection, resultSet);
}
/**
* Wraps the given result set in a delegate.
*
* @param statement
* The Statement which created the ResultSet.
* @param resultSet
* The ResultSet to wrap.
* @return a new delegate.
*/
public static ResultSet wrapResultSet(final Statement statement, final ResultSet resultSet) {
if (null == resultSet) {
return null;
}
return new DelegatingResultSet(statement, resultSet);
}
/** My delegate. **/
private final ResultSet resultSet;
/** The Statement that created me, if any. **/
private Statement statement;
/** The Connection that created me, if any. **/
private Connection connection;
/**
* Creates a wrapper for the ResultSet which traces this ResultSet to the Connection which created it (via, for
* example DatabaseMetadata), and the code which created it.
*
* Private to ensure all construction is {@link #wrapResultSet(Connection, ResultSet)}
*
*
* @param connection
* Connection which created this ResultSet
* @param resultSet
* ResultSet to wrap
*/
private DelegatingResultSet(final Connection connection, final ResultSet resultSet) {
super((AbandonedTrace) connection);
this.connection = connection;
this.resultSet = resultSet;
}
/**
* Creates a wrapper for the ResultSet which traces this ResultSet to the Statement which created it and the code
* which created it.
*
* Private to ensure all construction is {@link #wrapResultSet(Statement, ResultSet)}
*
*
* @param statement
* The Statement which created the ResultSet.
* @param resultSet
* The ResultSet to wrap.
*/
private DelegatingResultSet(final Statement statement, final ResultSet resultSet) {
super((AbandonedTrace) statement);
this.statement = statement;
this.resultSet = resultSet;
}
@Override
public boolean absolute(final int row) throws SQLException {
try {
return resultSet.absolute(row);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public void afterLast() throws SQLException {
try {
resultSet.afterLast();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void beforeFirst() throws SQLException {
try {
resultSet.beforeFirst();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void cancelRowUpdates() throws SQLException {
try {
resultSet.cancelRowUpdates();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void clearWarnings() throws SQLException {
try {
resultSet.clearWarnings();
} catch (final SQLException e) {
handleException(e);
}
}
/**
* Wrapper for close of ResultSet which removes this result set from being traced then calls close on the original
* ResultSet.
*/
@Override
public void close() throws SQLException {
try {
if (statement != null) {
removeThisTrace(statement);
statement = null;
}
if (connection != null) {
removeThisTrace(connection);
connection = null;
}
resultSet.close();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void deleteRow() throws SQLException {
try {
resultSet.deleteRow();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public int findColumn(final String columnName) throws SQLException {
try {
return resultSet.findColumn(columnName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public boolean first() throws SQLException {
try {
return resultSet.first();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public Array getArray(final int i) throws SQLException {
try {
return resultSet.getArray(i);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Array getArray(final String colName) throws SQLException {
try {
return resultSet.getArray(colName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public InputStream getAsciiStream(final int columnIndex) throws SQLException {
try {
return resultSet.getAsciiStream(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public InputStream getAsciiStream(final String columnName) throws SQLException {
try {
return resultSet.getAsciiStream(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public BigDecimal getBigDecimal(final int columnIndex) throws SQLException {
try {
return resultSet.getBigDecimal(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/** @deprecated Use {@link #getBigDecimal(int)} */
@Deprecated
@Override
public BigDecimal getBigDecimal(final int columnIndex, final int scale) throws SQLException {
try {
return resultSet.getBigDecimal(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public BigDecimal getBigDecimal(final String columnName) throws SQLException {
try {
return resultSet.getBigDecimal(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/** @deprecated Use {@link #getBigDecimal(String)} */
@Deprecated
@Override
public BigDecimal getBigDecimal(final String columnName, final int scale) throws SQLException {
try {
return resultSet.getBigDecimal(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public InputStream getBinaryStream(final int columnIndex) throws SQLException {
try {
return resultSet.getBinaryStream(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public InputStream getBinaryStream(final String columnName) throws SQLException {
try {
return resultSet.getBinaryStream(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Blob getBlob(final int i) throws SQLException {
try {
return resultSet.getBlob(i);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Blob getBlob(final String colName) throws SQLException {
try {
return resultSet.getBlob(colName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public boolean getBoolean(final int columnIndex) throws SQLException {
try {
return resultSet.getBoolean(columnIndex);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean getBoolean(final String columnName) throws SQLException {
try {
return resultSet.getBoolean(columnName);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public byte getByte(final int columnIndex) throws SQLException {
try {
return resultSet.getByte(columnIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public byte getByte(final String columnName) throws SQLException {
try {
return resultSet.getByte(columnName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public byte[] getBytes(final int columnIndex) throws SQLException {
try {
return resultSet.getBytes(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public byte[] getBytes(final String columnName) throws SQLException {
try {
return resultSet.getBytes(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Reader getCharacterStream(final int columnIndex) throws SQLException {
try {
return resultSet.getCharacterStream(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Reader getCharacterStream(final String columnName) throws SQLException {
try {
return resultSet.getCharacterStream(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Clob getClob(final int i) throws SQLException {
try {
return resultSet.getClob(i);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Clob getClob(final String colName) throws SQLException {
try {
return resultSet.getClob(colName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public int getConcurrency() throws SQLException {
try {
return resultSet.getConcurrency();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public String getCursorName() throws SQLException {
try {
return resultSet.getCursorName();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final int columnIndex) throws SQLException {
try {
return resultSet.getDate(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final int columnIndex, final Calendar cal) throws SQLException {
try {
return resultSet.getDate(columnIndex, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final String columnName) throws SQLException {
try {
return resultSet.getDate(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Date getDate(final String columnName, final Calendar cal) throws SQLException {
try {
return resultSet.getDate(columnName, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/**
* Gets my delegate.
*
* @return my delegate.
*/
public ResultSet getDelegate() {
return resultSet;
}
@Override
public double getDouble(final int columnIndex) throws SQLException {
try {
return resultSet.getDouble(columnIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public double getDouble(final String columnName) throws SQLException {
try {
return resultSet.getDouble(columnName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getFetchDirection() throws SQLException {
try {
return resultSet.getFetchDirection();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getFetchSize() throws SQLException {
try {
return resultSet.getFetchSize();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public float getFloat(final int columnIndex) throws SQLException {
try {
return resultSet.getFloat(columnIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public float getFloat(final String columnName) throws SQLException {
try {
return resultSet.getFloat(columnName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getHoldability() throws SQLException {
try {
return resultSet.getHoldability();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* If my underlying {@link ResultSet} is not a {@code DelegatingResultSet}, returns it, otherwise recursively
* invokes this method on my delegate.
*
* Hence this method will return the first delegate that is not a {@code DelegatingResultSet}, or {@code null} when
* no non-{@code DelegatingResultSet} delegate can be found by traversing this chain.
*
*
* This method is useful when you may have nested {@code DelegatingResultSet}s, and you want to make sure to obtain
* a "genuine" {@link ResultSet}.
*
*
* @return the innermost delegate.
*/
@SuppressWarnings("resource")
public ResultSet getInnermostDelegate() {
ResultSet r = resultSet;
while (r instanceof DelegatingResultSet) {
r = ((DelegatingResultSet) r).getDelegate();
if (this == r) {
return null;
}
}
return r;
}
@Override
public int getInt(final int columnIndex) throws SQLException {
try {
return resultSet.getInt(columnIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getInt(final String columnName) throws SQLException {
try {
return resultSet.getInt(columnName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public long getLong(final int columnIndex) throws SQLException {
try {
return resultSet.getLong(columnIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public long getLong(final String columnName) throws SQLException {
try {
return resultSet.getLong(columnName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public ResultSetMetaData getMetaData() throws SQLException {
try {
return resultSet.getMetaData();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Reader getNCharacterStream(final int columnIndex) throws SQLException {
try {
return resultSet.getNCharacterStream(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Reader getNCharacterStream(final String columnLabel) throws SQLException {
try {
return resultSet.getNCharacterStream(columnLabel);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public NClob getNClob(final int columnIndex) throws SQLException {
try {
return resultSet.getNClob(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public NClob getNClob(final String columnLabel) throws SQLException {
try {
return resultSet.getNClob(columnLabel);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getNString(final int columnIndex) throws SQLException {
try {
return resultSet.getNString(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getNString(final String columnLabel) throws SQLException {
try {
return resultSet.getNString(columnLabel);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final int columnIndex) throws SQLException {
try {
return resultSet.getObject(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public T getObject(final int columnIndex, final Class type) throws SQLException {
try {
return Jdbc41Bridge.getObject(resultSet, columnIndex, type);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final int i, final Map> map) throws SQLException {
try {
return resultSet.getObject(i, map);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final String columnName) throws SQLException {
try {
return resultSet.getObject(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public T getObject(final String columnLabel, final Class type) throws SQLException {
try {
return Jdbc41Bridge.getObject(resultSet, columnLabel, type);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Object getObject(final String colName, final Map> map) throws SQLException {
try {
return resultSet.getObject(colName, map);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Ref getRef(final int i) throws SQLException {
try {
return resultSet.getRef(i);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Ref getRef(final String colName) throws SQLException {
try {
return resultSet.getRef(colName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public int getRow() throws SQLException {
try {
return resultSet.getRow();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public RowId getRowId(final int columnIndex) throws SQLException {
try {
return resultSet.getRowId(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public RowId getRowId(final String columnLabel) throws SQLException {
try {
return resultSet.getRowId(columnLabel);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public short getShort(final int columnIndex) throws SQLException {
try {
return resultSet.getShort(columnIndex);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public short getShort(final String columnName) throws SQLException {
try {
return resultSet.getShort(columnName);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public SQLXML getSQLXML(final int columnIndex) throws SQLException {
try {
return resultSet.getSQLXML(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public SQLXML getSQLXML(final String columnLabel) throws SQLException {
try {
return resultSet.getSQLXML(columnLabel);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Statement getStatement() throws SQLException {
return statement;
}
@Override
public String getString(final int columnIndex) throws SQLException {
try {
return resultSet.getString(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public String getString(final String columnName) throws SQLException {
try {
return resultSet.getString(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final int columnIndex) throws SQLException {
try {
return resultSet.getTime(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final int columnIndex, final Calendar cal) throws SQLException {
try {
return resultSet.getTime(columnIndex, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final String columnName) throws SQLException {
try {
return resultSet.getTime(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Time getTime(final String columnName, final Calendar cal) throws SQLException {
try {
return resultSet.getTime(columnName, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final int columnIndex) throws SQLException {
try {
return resultSet.getTimestamp(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final int columnIndex, final Calendar cal) throws SQLException {
try {
return resultSet.getTimestamp(columnIndex, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final String columnName) throws SQLException {
try {
return resultSet.getTimestamp(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public Timestamp getTimestamp(final String columnName, final Calendar cal) throws SQLException {
try {
return resultSet.getTimestamp(columnName, cal);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public int getType() throws SQLException {
try {
return resultSet.getType();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/** @deprecated Use {@link #getCharacterStream(int)} */
@Deprecated
@Override
public InputStream getUnicodeStream(final int columnIndex) throws SQLException {
try {
return resultSet.getUnicodeStream(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/** @deprecated Use {@link #getCharacterStream(String)} */
@Deprecated
@Override
public InputStream getUnicodeStream(final String columnName) throws SQLException {
try {
return resultSet.getUnicodeStream(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public java.net.URL getURL(final int columnIndex) throws SQLException {
try {
return resultSet.getURL(columnIndex);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public java.net.URL getURL(final String columnName) throws SQLException {
try {
return resultSet.getURL(columnName);
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public SQLWarning getWarnings() throws SQLException {
try {
return resultSet.getWarnings();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
protected void handleException(final SQLException e) throws SQLException {
if (statement instanceof DelegatingStatement) {
((DelegatingStatement) statement).handleException(e);
} else if (connection instanceof DelegatingConnection) {
((DelegatingConnection) connection).handleException(e);
} else {
throw e;
}
}
@Override
public void insertRow() throws SQLException {
try {
resultSet.insertRow();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public boolean isAfterLast() throws SQLException {
try {
return resultSet.isAfterLast();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isBeforeFirst() throws SQLException {
try {
return resultSet.isBeforeFirst();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isClosed() throws SQLException {
try {
return resultSet.isClosed();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isFirst() throws SQLException {
try {
return resultSet.isFirst();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isLast() throws SQLException {
try {
return resultSet.isLast();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isWrapperFor(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
}
if (iface.isAssignableFrom(resultSet.getClass())) {
return true;
}
return resultSet.isWrapperFor(iface);
}
@Override
public boolean last() throws SQLException {
try {
return resultSet.last();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public void moveToCurrentRow() throws SQLException {
try {
resultSet.moveToCurrentRow();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void moveToInsertRow() throws SQLException {
try {
resultSet.moveToInsertRow();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public boolean next() throws SQLException {
try {
return resultSet.next();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean previous() throws SQLException {
try {
return resultSet.previous();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public void refreshRow() throws SQLException {
try {
resultSet.refreshRow();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public boolean relative(final int rows) throws SQLException {
try {
return resultSet.relative(rows);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean rowDeleted() throws SQLException {
try {
return resultSet.rowDeleted();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean rowInserted() throws SQLException {
try {
return resultSet.rowInserted();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean rowUpdated() throws SQLException {
try {
return resultSet.rowUpdated();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public void setFetchDirection(final int direction) throws SQLException {
try {
resultSet.setFetchDirection(direction);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setFetchSize(final int rows) throws SQLException {
try {
resultSet.setFetchSize(rows);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public synchronized String toString() {
return super.toString() + "[resultSet=" + resultSet + ", statement=" + statement + ", connection=" + connection + "]";
}
@Override
public T unwrap(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
}
if (iface.isAssignableFrom(resultSet.getClass())) {
return iface.cast(resultSet);
}
return resultSet.unwrap(iface);
}
@Override
public void updateArray(final int columnIndex, final Array x) throws SQLException {
try {
resultSet.updateArray(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateArray(final String columnName, final Array x) throws SQLException {
try {
resultSet.updateArray(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateAsciiStream(final int columnIndex, final InputStream inputStream) throws SQLException {
try {
resultSet.updateAsciiStream(columnIndex, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateAsciiStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
try {
resultSet.updateAsciiStream(columnIndex, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateAsciiStream(final int columnIndex, final InputStream inputStream, final long length)
throws SQLException {
try {
resultSet.updateAsciiStream(columnIndex, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateAsciiStream(final String columnLabel, final InputStream inputStream) throws SQLException {
try {
resultSet.updateAsciiStream(columnLabel, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateAsciiStream(final String columnName, final InputStream x, final int length) throws SQLException {
try {
resultSet.updateAsciiStream(columnName, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateAsciiStream(final String columnLabel, final InputStream inputStream, final long length)
throws SQLException {
try {
resultSet.updateAsciiStream(columnLabel, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBigDecimal(final int columnIndex, final BigDecimal x) throws SQLException {
try {
resultSet.updateBigDecimal(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBigDecimal(final String columnName, final BigDecimal x) throws SQLException {
try {
resultSet.updateBigDecimal(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBinaryStream(final int columnIndex, final InputStream inputStream) throws SQLException {
try {
resultSet.updateBinaryStream(columnIndex, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBinaryStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
try {
resultSet.updateBinaryStream(columnIndex, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBinaryStream(final int columnIndex, final InputStream inputStream, final long length)
throws SQLException {
try {
resultSet.updateBinaryStream(columnIndex, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBinaryStream(final String columnLabel, final InputStream inputStream) throws SQLException {
try {
resultSet.updateBinaryStream(columnLabel, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBinaryStream(final String columnName, final InputStream x, final int length) throws SQLException {
try {
resultSet.updateBinaryStream(columnName, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBinaryStream(final String columnLabel, final InputStream inputStream, final long length)
throws SQLException {
try {
resultSet.updateBinaryStream(columnLabel, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBlob(final int columnIndex, final Blob x) throws SQLException {
try {
resultSet.updateBlob(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBlob(final int columnIndex, final InputStream inputStream) throws SQLException {
try {
resultSet.updateBlob(columnIndex, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBlob(final int columnIndex, final InputStream inputStream, final long length)
throws SQLException {
try {
resultSet.updateBlob(columnIndex, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBlob(final String columnName, final Blob x) throws SQLException {
try {
resultSet.updateBlob(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBlob(final String columnLabel, final InputStream inputStream) throws SQLException {
try {
resultSet.updateBlob(columnLabel, inputStream);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBlob(final String columnLabel, final InputStream inputStream, final long length)
throws SQLException {
try {
resultSet.updateBlob(columnLabel, inputStream, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBoolean(final int columnIndex, final boolean x) throws SQLException {
try {
resultSet.updateBoolean(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBoolean(final String columnName, final boolean x) throws SQLException {
try {
resultSet.updateBoolean(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateByte(final int columnIndex, final byte x) throws SQLException {
try {
resultSet.updateByte(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateByte(final String columnName, final byte x) throws SQLException {
try {
resultSet.updateByte(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBytes(final int columnIndex, final byte[] x) throws SQLException {
try {
resultSet.updateBytes(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateBytes(final String columnName, final byte[] x) throws SQLException {
try {
resultSet.updateBytes(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateCharacterStream(final int columnIndex, final Reader reader) throws SQLException {
try {
resultSet.updateCharacterStream(columnIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateCharacterStream(final int columnIndex, final Reader x, final int length) throws SQLException {
try {
resultSet.updateCharacterStream(columnIndex, x, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateCharacterStream(final int columnIndex, final Reader reader, final long length)
throws SQLException {
try {
resultSet.updateCharacterStream(columnIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
try {
resultSet.updateCharacterStream(columnLabel, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateCharacterStream(final String columnName, final Reader reader, final int length)
throws SQLException {
try {
resultSet.updateCharacterStream(columnName, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateCharacterStream(final String columnLabel, final Reader reader, final long length)
throws SQLException {
try {
resultSet.updateCharacterStream(columnLabel, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateClob(final int columnIndex, final Clob x) throws SQLException {
try {
resultSet.updateClob(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateClob(final int columnIndex, final Reader reader) throws SQLException {
try {
resultSet.updateClob(columnIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateClob(columnIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateClob(final String columnName, final Clob x) throws SQLException {
try {
resultSet.updateClob(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateClob(final String columnLabel, final Reader reader) throws SQLException {
try {
resultSet.updateClob(columnLabel, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateClob(columnLabel, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateDate(final int columnIndex, final Date x) throws SQLException {
try {
resultSet.updateDate(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateDate(final String columnName, final Date x) throws SQLException {
try {
resultSet.updateDate(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateDouble(final int columnIndex, final double x) throws SQLException {
try {
resultSet.updateDouble(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateDouble(final String columnName, final double x) throws SQLException {
try {
resultSet.updateDouble(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateFloat(final int columnIndex, final float x) throws SQLException {
try {
resultSet.updateFloat(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateFloat(final String columnName, final float x) throws SQLException {
try {
resultSet.updateFloat(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateInt(final int columnIndex, final int x) throws SQLException {
try {
resultSet.updateInt(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateInt(final String columnName, final int x) throws SQLException {
try {
resultSet.updateInt(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateLong(final int columnIndex, final long x) throws SQLException {
try {
resultSet.updateLong(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateLong(final String columnName, final long x) throws SQLException {
try {
resultSet.updateLong(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNCharacterStream(final int columnIndex, final Reader reader) throws SQLException {
try {
resultSet.updateNCharacterStream(columnIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNCharacterStream(final int columnIndex, final Reader reader, final long length)
throws SQLException {
try {
resultSet.updateNCharacterStream(columnIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
try {
resultSet.updateNCharacterStream(columnLabel, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNCharacterStream(final String columnLabel, final Reader reader, final long length)
throws SQLException {
try {
resultSet.updateNCharacterStream(columnLabel, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNClob(final int columnIndex, final NClob value) throws SQLException {
try {
resultSet.updateNClob(columnIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNClob(final int columnIndex, final Reader reader) throws SQLException {
try {
resultSet.updateNClob(columnIndex, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateNClob(columnIndex, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNClob(final String columnLabel, final NClob value) throws SQLException {
try {
resultSet.updateNClob(columnLabel, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNClob(final String columnLabel, final Reader reader) throws SQLException {
try {
resultSet.updateNClob(columnLabel, reader);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateNClob(columnLabel, reader, length);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNString(final int columnIndex, final String value) throws SQLException {
try {
resultSet.updateNString(columnIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNString(final String columnLabel, final String value) throws SQLException {
try {
resultSet.updateNString(columnLabel, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNull(final int columnIndex) throws SQLException {
try {
resultSet.updateNull(columnIndex);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateNull(final String columnName) throws SQLException {
try {
resultSet.updateNull(columnName);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateObject(final int columnIndex, final Object x) throws SQLException {
try {
resultSet.updateObject(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateObject(final int columnIndex, final Object x, final int scale) throws SQLException {
try {
resultSet.updateObject(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void updateObject(final int columnIndex, final Object x, final SQLType targetSqlType) throws SQLException {
try {
resultSet.updateObject(columnIndex, x, targetSqlType);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void updateObject(final int columnIndex, final Object x, final SQLType targetSqlType, final int scaleOrLength) throws SQLException {
try {
resultSet.updateObject(columnIndex, x, targetSqlType, scaleOrLength);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateObject(final String columnName, final Object x) throws SQLException {
try {
resultSet.updateObject(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateObject(final String columnName, final Object x, final int scale) throws SQLException {
try {
resultSet.updateObject(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void updateObject(final String columnLabel, final Object x, final SQLType targetSqlType) throws SQLException {
try {
resultSet.updateObject(columnLabel, x, targetSqlType);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void updateObject(final String columnLabel, final Object x, final SQLType targetSqlType, final int scaleOrLength)
throws SQLException {
try {
resultSet.updateObject(columnLabel, x, targetSqlType, scaleOrLength);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateRef(final int columnIndex, final Ref x) throws SQLException {
try {
resultSet.updateRef(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateRef(final String columnName, final Ref x) throws SQLException {
try {
resultSet.updateRef(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateRow() throws SQLException {
try {
resultSet.updateRow();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateRowId(final int columnIndex, final RowId value) throws SQLException {
try {
resultSet.updateRowId(columnIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateRowId(final String columnLabel, final RowId value) throws SQLException {
try {
resultSet.updateRowId(columnLabel, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateShort(final int columnIndex, final short x) throws SQLException {
try {
resultSet.updateShort(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateShort(final String columnName, final short x) throws SQLException {
try {
resultSet.updateShort(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateSQLXML(final int columnIndex, final SQLXML value) throws SQLException {
try {
resultSet.updateSQLXML(columnIndex, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateSQLXML(final String columnLabel, final SQLXML value) throws SQLException {
try {
resultSet.updateSQLXML(columnLabel, value);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateString(final int columnIndex, final String x) throws SQLException {
try {
resultSet.updateString(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateString(final String columnName, final String x) throws SQLException {
try {
resultSet.updateString(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateTime(final int columnIndex, final Time x) throws SQLException {
try {
resultSet.updateTime(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateTime(final String columnName, final Time x) throws SQLException {
try {
resultSet.updateTime(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateTimestamp(final int columnIndex, final Timestamp x) throws SQLException {
try {
resultSet.updateTimestamp(columnIndex, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void updateTimestamp(final String columnName, final Timestamp x) throws SQLException {
try {
resultSet.updateTimestamp(columnName, x);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public boolean wasNull() throws SQLException {
try {
return resultSet.wasNull();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/DelegatingStatement.java0000664 0000000 0000000 00000056377 14473117325 0033247 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
/**
* A base delegating implementation of {@link Statement}.
*
* All of the methods from the {@link Statement} interface simply check to see that the {@link Statement} is active, and
* call the corresponding method on the "delegate" provided in my constructor.
*
* Extends AbandonedTrace to implement Statement tracking and logging of code which created the Statement. Tracking the
* Statement ensures that the Connection which created it can close any open Statement's on Connection close.
*
* @since 2.0
*/
public class DelegatingStatement extends AbandonedTrace implements Statement {
/** My delegate. */
private Statement statement;
/** The connection that created me. **/
private DelegatingConnection connection;
private boolean closed;
/**
* Create a wrapper for the Statement which traces this Statement to the Connection which created it and the code
* which created it.
*
* @param statement
* the {@link Statement} to delegate all calls to.
* @param connection
* the {@link DelegatingConnection} that created this statement.
*/
public DelegatingStatement(final DelegatingConnection connection, final Statement statement) {
super(connection);
this.statement = statement;
this.connection = connection;
}
/**
*
* @throws SQLException
* thrown by the delegating statement.
* @since 2.4.0 made public, was protected in 2.3.0.
*/
public void activate() throws SQLException {
if (statement instanceof DelegatingStatement) {
((DelegatingStatement) statement).activate();
}
}
@Override
public void addBatch(final String sql) throws SQLException {
checkOpen();
try {
statement.addBatch(sql);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void cancel() throws SQLException {
checkOpen();
try {
statement.cancel();
} catch (final SQLException e) {
handleException(e);
}
}
protected void checkOpen() throws SQLException {
if (isClosed()) {
throw new SQLException(this.getClass().getName() + " with address: \"" + this.toString() + "\" is closed.");
}
}
@Override
public void clearBatch() throws SQLException {
checkOpen();
try {
statement.clearBatch();
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void clearWarnings() throws SQLException {
checkOpen();
try {
statement.clearWarnings();
} catch (final SQLException e) {
handleException(e);
}
}
/**
* Close this DelegatingStatement, and close any ResultSets that were not explicitly closed.
*/
@Override
public void close() throws SQLException {
if (isClosed()) {
return;
}
final List thrownList = new ArrayList<>();
try {
if (connection != null) {
connection.removeTrace(this);
connection = null;
}
// The JDBC spec requires that a statement close any open
// ResultSet's when it is closed.
// FIXME The PreparedStatement we're wrapping should handle this for us.
// See bug 17301 for what could happen when ResultSets are closed twice.
final List traceList = getTrace();
if (traceList != null) {
traceList.forEach(trace -> trace.close(e -> {
if (connection != null) {
// Does not rethrow e.
connection.handleExceptionNoThrow(e);
}
thrownList.add(e);
}));
clearTrace();
}
Utils.close(statement, e -> {
if (connection != null) {
// Does not rethrow e.
connection.handleExceptionNoThrow(e);
}
thrownList.add(e);
});
} finally {
closed = true;
statement = null;
if (!thrownList.isEmpty()) {
throw new SQLExceptionList(thrownList);
}
}
}
@Override
public void closeOnCompletion() throws SQLException {
checkOpen();
try {
Jdbc41Bridge.closeOnCompletion(statement);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public boolean execute(final String sql) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.execute(sql);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean execute(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.execute(sql, autoGeneratedKeys);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean execute(final String sql, final int[] columnIndexes) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.execute(sql, columnIndexes);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean execute(final String sql, final String[] columnNames) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.execute(sql, columnNames);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public int[] executeBatch() throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeBatch();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
/**
* @since 2.5.0
*/
@Override
public long[] executeLargeBatch() throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeLargeBatch();
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/**
* @since 2.5.0
*/
@Override
public long executeLargeUpdate(final String sql) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeLargeUpdate(sql);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* @since 2.5.0
*/
@Override
public long executeLargeUpdate(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeLargeUpdate(sql, autoGeneratedKeys);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* @since 2.5.0
*/
@Override
public long executeLargeUpdate(final String sql, final int[] columnIndexes) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeLargeUpdate(sql, columnIndexes);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* @since 2.5.0
*/
@Override
public long executeLargeUpdate(final String sql, final String[] columnNames) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeLargeUpdate(sql, columnNames);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public ResultSet executeQuery(final String sql) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return DelegatingResultSet.wrapResultSet(this, statement.executeQuery(sql));
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public int executeUpdate(final String sql) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeUpdate(sql);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int executeUpdate(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeUpdate(sql, autoGeneratedKeys);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int executeUpdate(final String sql, final int[] columnIndexes) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeUpdate(sql, columnIndexes);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int executeUpdate(final String sql, final String[] columnNames) throws SQLException {
checkOpen();
setLastUsedInParent();
try {
return statement.executeUpdate(sql, columnNames);
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
protected void finalize() throws Throwable {
// This is required because of statement pooling. The poolable
// statements will always be strongly held by the statement pool. If the
// delegating statements that wrap the poolable statement are not
// strongly held they will be garbage collected but at that point the
// poolable statements need to be returned to the pool else there will
// be a leak of statements from the pool. Closing this statement will
// close all the wrapped statements and return any poolable statements
// to the pool.
close();
super.finalize();
}
@Override
public Connection getConnection() throws SQLException {
checkOpen();
return getConnectionInternal(); // return the delegating connection that created this
}
protected DelegatingConnection getConnectionInternal() {
return connection;
}
/**
* Returns my underlying {@link Statement}.
*
* @return my underlying {@link Statement}.
* @see #getInnermostDelegate
*/
public Statement getDelegate() {
return statement;
}
@Override
public int getFetchDirection() throws SQLException {
checkOpen();
try {
return statement.getFetchDirection();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getFetchSize() throws SQLException {
checkOpen();
try {
return statement.getFetchSize();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public ResultSet getGeneratedKeys() throws SQLException {
checkOpen();
try {
return DelegatingResultSet.wrapResultSet(this, statement.getGeneratedKeys());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
/**
* If my underlying {@link Statement} is not a {@code DelegatingStatement}, returns it, otherwise recursively
* invokes this method on my delegate.
*
* Hence this method will return the first delegate that is not a {@code DelegatingStatement} or {@code null} when
* no non-{@code DelegatingStatement} delegate can be found by traversing this chain.
*
*
* This method is useful when you may have nested {@code DelegatingStatement}s, and you want to make sure to obtain
* a "genuine" {@link Statement}.
*
*
* @return The innermost delegate.
*
* @see #getDelegate
*/
@SuppressWarnings("resource")
public Statement getInnermostDelegate() {
Statement s = statement;
while (s instanceof DelegatingStatement) {
s = ((DelegatingStatement) s).getDelegate();
if (this == s) {
return null;
}
}
return s;
}
/**
* @since 2.5.0
*/
@Override
public long getLargeMaxRows() throws SQLException {
checkOpen();
try {
return statement.getLargeMaxRows();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
/**
* @since 2.5.0
*/
@Override
public long getLargeUpdateCount() throws SQLException {
checkOpen();
try {
return statement.getLargeUpdateCount();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxFieldSize() throws SQLException {
checkOpen();
try {
return statement.getMaxFieldSize();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getMaxRows() throws SQLException {
checkOpen();
try {
return statement.getMaxRows();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public boolean getMoreResults() throws SQLException {
checkOpen();
try {
return statement.getMoreResults();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean getMoreResults(final int current) throws SQLException {
checkOpen();
try {
return statement.getMoreResults(current);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public int getQueryTimeout() throws SQLException {
checkOpen();
try {
return statement.getQueryTimeout();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@SuppressWarnings("resource") // Caller is responsible for closing the resource.
@Override
public ResultSet getResultSet() throws SQLException {
checkOpen();
try {
return DelegatingResultSet.wrapResultSet(this, statement.getResultSet());
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
public int getResultSetConcurrency() throws SQLException {
checkOpen();
try {
return statement.getResultSetConcurrency();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getResultSetHoldability() throws SQLException {
checkOpen();
try {
return statement.getResultSetHoldability();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getResultSetType() throws SQLException {
checkOpen();
try {
return statement.getResultSetType();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public int getUpdateCount() throws SQLException {
checkOpen();
try {
return statement.getUpdateCount();
} catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
public SQLWarning getWarnings() throws SQLException {
checkOpen();
try {
return statement.getWarnings();
} catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
protected void handleException(final SQLException e) throws SQLException {
if (connection == null) {
throw e;
}
connection.handleException(e);
}
/*
* Note: This method was protected prior to JDBC 4.
*/
@Override
public boolean isClosed() throws SQLException {
return closed;
}
protected boolean isClosedInternal() {
return closed;
}
@Override
public boolean isCloseOnCompletion() throws SQLException {
checkOpen();
try {
return Jdbc41Bridge.isCloseOnCompletion(statement);
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isPoolable() throws SQLException {
checkOpen();
try {
return statement.isPoolable();
} catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
public boolean isWrapperFor(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
}
if (iface.isAssignableFrom(statement.getClass())) {
return true;
}
return statement.isWrapperFor(iface);
}
/**
*
* @throws SQLException
* thrown by the delegating statement.
* @since 2.4.0 made public, was protected in 2.3.0.
*/
public void passivate() throws SQLException {
if (statement instanceof DelegatingStatement) {
((DelegatingStatement) statement).passivate();
}
}
protected void setClosedInternal(final boolean closed) {
this.closed = closed;
}
@Override
public void setCursorName(final String name) throws SQLException {
checkOpen();
try {
statement.setCursorName(name);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* Sets my delegate.
*
* @param statement
* my delegate.
*/
public void setDelegate(final Statement statement) {
this.statement = statement;
}
@Override
public void setEscapeProcessing(final boolean enable) throws SQLException {
checkOpen();
try {
statement.setEscapeProcessing(enable);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setFetchDirection(final int direction) throws SQLException {
checkOpen();
try {
statement.setFetchDirection(direction);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setFetchSize(final int rows) throws SQLException {
checkOpen();
try {
statement.setFetchSize(rows);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* @since 2.5.0
*/
@Override
public void setLargeMaxRows(final long max) throws SQLException {
checkOpen();
try {
statement.setLargeMaxRows(max);
} catch (final SQLException e) {
handleException(e);
}
}
private void setLastUsedInParent() {
if (connection != null) {
connection.setLastUsed();
}
}
@Override
public void setMaxFieldSize(final int max) throws SQLException {
checkOpen();
try {
statement.setMaxFieldSize(max);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setMaxRows(final int max) throws SQLException {
checkOpen();
try {
statement.setMaxRows(max);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setPoolable(final boolean poolable) throws SQLException {
checkOpen();
try {
statement.setPoolable(poolable);
} catch (final SQLException e) {
handleException(e);
}
}
@Override
public void setQueryTimeout(final int seconds) throws SQLException {
checkOpen();
try {
statement.setQueryTimeout(seconds);
} catch (final SQLException e) {
handleException(e);
}
}
/**
* Returns a String representation of this object.
*
* @return String
*/
@Override
public synchronized String toString() {
return statement == null ? "NULL" : statement.toString();
}
@Override
public T unwrap(final Class iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
}
if (iface.isAssignableFrom(statement.getClass())) {
return iface.cast(statement);
}
return statement.unwrap(iface);
}
}
DriverConnectionFactory.java 0000664 0000000 0000000 00000004635 14473117325 0034031 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.SQLException;
import java.util.Properties;
/**
* A {@link Driver}-based implementation of {@link ConnectionFactory}.
*
* @since 2.0
*/
public class DriverConnectionFactory implements ConnectionFactory {
private final String connectionString;
private final Driver driver;
private final Properties properties;
/**
* Constructs a connection factory for a given Driver.
*
* @param driver The Driver.
* @param connectString The connection string.
* @param properties The connection properties.
*/
public DriverConnectionFactory(final Driver driver, final String connectString, final Properties properties) {
this.driver = driver;
this.connectionString = connectString;
this.properties = properties;
}
@Override
public Connection createConnection() throws SQLException {
return driver.connect(connectionString, properties);
}
/**
* @return The connection String.
* @since 2.6.0
*/
public String getConnectionString() {
return connectionString;
}
/**
* @return The Driver.
* @since 2.6.0
*/
public Driver getDriver() {
return driver;
}
/**
* @return The Properties.
* @since 2.6.0
*/
public Properties getProperties() {
return properties;
}
@Override
public String toString() {
return this.getClass().getName() + " [" + driver + ";" + connectionString + ";"
+ Utils.cloneWithoutCredentials(properties) + "]";
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/DriverFactory.java 0000664 0000000 0000000 00000006667 14473117325 0032077 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
/*
* Creates {@link Driver} instances.
*
* @since 2.7.0
*/
final class DriverFactory {
static Driver createDriver(final BasicDataSource basicDataSource) throws SQLException {
// Load the JDBC driver class
Driver driverToUse = basicDataSource.getDriver();
final String driverClassName = basicDataSource.getDriverClassName();
final ClassLoader driverClassLoader = basicDataSource.getDriverClassLoader();
final String url = basicDataSource.getUrl();
if (driverToUse == null) {
Class driverFromCCL = null;
if (driverClassName != null) {
try {
try {
if (driverClassLoader == null) {
driverFromCCL = Class.forName(driverClassName);
} else {
driverFromCCL = Class.forName(driverClassName, true, driverClassLoader);
}
} catch (final ClassNotFoundException cnfe) {
driverFromCCL = Thread.currentThread().getContextClassLoader().loadClass(driverClassName);
}
} catch (final Exception t) {
final String message = "Cannot load JDBC driver class '" + driverClassName + "'";
basicDataSource.log(message, t);
throw new SQLException(message, t);
}
}
try {
if (driverFromCCL == null) {
driverToUse = DriverManager.getDriver(url);
} else {
// Usage of DriverManager is not possible, as it does not
// respect the ContextClassLoader
// N.B. This cast may cause ClassCastException which is
// handled below
driverToUse = (Driver) driverFromCCL.getConstructor().newInstance();
if (!driverToUse.acceptsURL(url)) {
throw new SQLException("No suitable driver", "08001");
}
}
} catch (final Exception t) {
final String message = "Cannot create JDBC driver of class '"
+ (driverClassName != null ? driverClassName : "") + "' for connect URL '" + url + "'";
basicDataSource.log(message, t);
throw new SQLException(message, t);
}
}
return driverToUse;
}
}
DriverManagerConnectionFactory.java 0000664 0000000 0000000 00000011745 14473117325 0035324 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/**
* A {@link DriverManager}-based implementation of {@link ConnectionFactory}.
*
* @since 2.0
*/
public class DriverManagerConnectionFactory implements ConnectionFactory {
static {
// Related to DBCP-212
// Driver manager does not sync loading of drivers that use the service
// provider interface. This will cause issues is multi-threaded
// environments. This hack makes sure the drivers are loaded before
// DBCP tries to use them.
DriverManager.getDrivers();
}
private final String connectionUri;
private final String userName;
private final char[] userPassword;
private final Properties properties;
/**
* Constructor for DriverManagerConnectionFactory.
*
* @param connectionUri
* a database connection string of the form {@code jdbc:subprotocol:subname}
* @since 2.2
*/
public DriverManagerConnectionFactory(final String connectionUri) {
this.connectionUri = connectionUri;
this.properties = new Properties();
this.userName = null;
this.userPassword = null;
}
/**
* Constructor for DriverManagerConnectionFactory.
*
* @param connectionUri
* a database connection string of the form {@code jdbc:subprotocol:subname}
* @param properties
* a list of arbitrary string tag/value pairs as connection arguments; normally at least a "user" and
* "password" property should be included.
*/
public DriverManagerConnectionFactory(final String connectionUri, final Properties properties) {
this.connectionUri = connectionUri;
this.properties = properties;
this.userName = null;
this.userPassword = null;
}
/**
* Constructor for DriverManagerConnectionFactory.
*
* @param connectionUri
* a database connection string of the form {@code jdbc:subprotocol:subname}
* @param userName
* the database user
* @param userPassword
* the user's password
*/
public DriverManagerConnectionFactory(final String connectionUri, final String userName,
final char[] userPassword) {
this.connectionUri = connectionUri;
this.userName = userName;
this.userPassword = Utils.clone(userPassword);
this.properties = null;
}
/**
* Constructor for DriverManagerConnectionFactory.
*
* @param connectionUri
* a database connection string of the form {@code jdbc:subprotocol:subname}
* @param userName
* the database user
* @param userPassword
* the user's password
*/
public DriverManagerConnectionFactory(final String connectionUri, final String userName,
final String userPassword) {
this.connectionUri = connectionUri;
this.userName = userName;
this.userPassword = Utils.toCharArray(userPassword);
this.properties = null;
}
@Override
public Connection createConnection() throws SQLException {
if (null == properties) {
if (userName == null && userPassword == null) {
return DriverManager.getConnection(connectionUri);
}
return DriverManager.getConnection(connectionUri, userName, Utils.toString(userPassword));
}
return DriverManager.getConnection(connectionUri, properties);
}
/**
* @return The connection URI.
* @since 2.6.0
*/
public String getConnectionUri() {
return connectionUri;
}
/**
* @return The Properties.
* @since 2.6.0
*/
public Properties getProperties() {
return properties;
}
/**
* @return The user name.
* @since 2.6.0
*/
public String getUserName() {
return userName;
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/Jdbc41Bridge.java 0000664 0000000 0000000 00000046220 14473117325 0031425 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Date;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.concurrent.Executor;
import java.util.logging.Logger;
import javax.sql.CommonDataSource;
/**
* Defines bridge methods to JDBC 4.1 (Java 7) methods to allow call sites to operate safely (without
* {@link AbstractMethodError}) when using a JDBC driver written for JDBC 4.0 (Java 6).
*
* There should be no need to this kind of code for JDBC 4.2 in Java 8 due to JDBC's use of default methods.
*
*
* This should probably be moved or at least copied in some form to Apache Commons DbUtils.
*
*
* @since 2.6.0
*/
public class Jdbc41Bridge {
/**
* Delegates to {@link Connection#abort(Executor)} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link Connection#abort(Executor)}, then call {@link Connection#close()}.
*
*
* @param connection
* the receiver
* @param executor
* See {@link Connection#abort(Executor)}.
* @throws SQLException
* See {@link Connection#abort(Executor)}.
* @see Connection#abort(Executor)
*/
public static void abort(final Connection connection, final Executor executor) throws SQLException {
try {
connection.abort(executor);
} catch (final AbstractMethodError e) {
connection.close();
}
}
/**
* Delegates to {@link Statement#closeOnCompletion()} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link Statement#closeOnCompletion()}, then just check that the connection
* is closed to then throw an SQLException.
*
*
* @param statement
* See {@link Statement#closeOnCompletion()}
* @throws SQLException
* See {@link Statement#closeOnCompletion()}
* @see Statement#closeOnCompletion()
*/
public static void closeOnCompletion(final Statement statement) throws SQLException {
try {
statement.closeOnCompletion();
} catch (final AbstractMethodError e) {
if (statement.isClosed()) {
throw new SQLException("Statement closed");
}
}
}
/**
* Delegates to {@link DatabaseMetaData#generatedKeyAlwaysReturned()} without throwing a
* {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link DatabaseMetaData#generatedKeyAlwaysReturned()}, then return false.
*
*
* @param databaseMetaData
* See {@link DatabaseMetaData#generatedKeyAlwaysReturned()}
* @return See {@link DatabaseMetaData#generatedKeyAlwaysReturned()}
* @throws SQLException
* See {@link DatabaseMetaData#generatedKeyAlwaysReturned()}
* @see DatabaseMetaData#generatedKeyAlwaysReturned()
*/
public static boolean generatedKeyAlwaysReturned(final DatabaseMetaData databaseMetaData) throws SQLException {
try {
return databaseMetaData.generatedKeyAlwaysReturned();
} catch (final AbstractMethodError e) {
// do nothing
return false;
}
}
/**
* Delegates to {@link Connection#getNetworkTimeout()} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link Connection#getNetworkTimeout()}, then return 0.
*
*
* @param connection
* the receiver
* @return See {@link Connection#getNetworkTimeout()}
* @throws SQLException
* See {@link Connection#getNetworkTimeout()}
* @see Connection#getNetworkTimeout()
*/
public static int getNetworkTimeout(final Connection connection) throws SQLException {
try {
return connection.getNetworkTimeout();
} catch (final AbstractMethodError e) {
return 0;
}
}
/**
* Delegates to {@link ResultSet#getObject(int, Class)} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link ResultSet#getObject(int, Class)}, then return 0.
*
*
* @param
* See {@link ResultSet#getObject(int, Class)}
* @param resultSet
* See {@link ResultSet#getObject(int, Class)}
* @param columnIndex
* See {@link ResultSet#getObject(int, Class)}
* @param type
* See {@link ResultSet#getObject(int, Class)}
* @return See {@link ResultSet#getObject(int, Class)}
* @throws SQLException
* See {@link ResultSet#getObject(int, Class)}
* @see ResultSet#getObject(int, Class)
*/
@SuppressWarnings("unchecked")
public static T getObject(final ResultSet resultSet, final int columnIndex, final Class type)
throws SQLException {
try {
return resultSet.getObject(columnIndex, type);
} catch (final AbstractMethodError e) {
if (type == String.class) {
return (T) resultSet.getString(columnIndex);
}
// Numbers
if (type == Integer.class) {
return (T) Integer.valueOf(resultSet.getInt(columnIndex));
}
if (type == Long.class) {
return (T) Long.valueOf(resultSet.getLong(columnIndex));
}
if (type == Double.class) {
return (T) Double.valueOf(resultSet.getDouble(columnIndex));
}
if (type == Float.class) {
return (T) Float.valueOf(resultSet.getFloat(columnIndex));
}
if (type == Short.class) {
return (T) Short.valueOf(resultSet.getShort(columnIndex));
}
if (type == BigDecimal.class) {
return (T) resultSet.getBigDecimal(columnIndex);
}
if (type == Byte.class) {
return (T) Byte.valueOf(resultSet.getByte(columnIndex));
}
// Dates
if (type == Date.class) {
return (T) resultSet.getDate(columnIndex);
}
if (type == Time.class) {
return (T) resultSet.getTime(columnIndex);
}
if (type == Timestamp.class) {
return (T) resultSet.getTimestamp(columnIndex);
}
// Streams
if (type == InputStream.class) {
return (T) resultSet.getBinaryStream(columnIndex);
}
if (type == Reader.class) {
return (T) resultSet.getCharacterStream(columnIndex);
}
// Other
if (type == Object.class) {
return (T) resultSet.getObject(columnIndex);
}
if (type == Boolean.class) {
return (T) Boolean.valueOf(resultSet.getBoolean(columnIndex));
}
if (type == Array.class) {
return (T) resultSet.getArray(columnIndex);
}
if (type == Blob.class) {
return (T) resultSet.getBlob(columnIndex);
}
if (type == Clob.class) {
return (T) resultSet.getClob(columnIndex);
}
if (type == Ref.class) {
return (T) resultSet.getRef(columnIndex);
}
if (type == RowId.class) {
return (T) resultSet.getRowId(columnIndex);
}
if (type == SQLXML.class) {
return (T) resultSet.getSQLXML(columnIndex);
}
if (type == URL.class) {
return (T) resultSet.getURL(columnIndex);
}
throw new SQLFeatureNotSupportedException(
String.format("resultSet=%s, columnIndex=%,d, type=%s", resultSet, columnIndex, type));
}
}
/**
* Delegates to {@link ResultSet#getObject(String, Class)} without throwing an {@link AbstractMethodError}.
*
* @param
* See {@link ResultSet#getObject(String, Class)}
* @param resultSet
* See {@link ResultSet#getObject(String, Class)}
* @param columnLabel
* See {@link ResultSet#getObject(String, Class)}
* @param type
* See {@link ResultSet#getObject(String, Class)}
* @return See {@link ResultSet#getObject(String, Class)}
* @throws SQLException
* See {@link ResultSet#getObject(String, Class)}
* @see ResultSet#getObject(int, Class)
*/
@SuppressWarnings("unchecked")
public static T getObject(final ResultSet resultSet, final String columnLabel, final Class type)
throws SQLException {
try {
return resultSet.getObject(columnLabel, type);
} catch (final AbstractMethodError e) {
// Numbers
if (type == Integer.class) {
return (T) Integer.valueOf(resultSet.getInt(columnLabel));
}
if (type == Long.class) {
return (T) Long.valueOf(resultSet.getLong(columnLabel));
}
if (type == Double.class) {
return (T) Double.valueOf(resultSet.getDouble(columnLabel));
}
if (type == Float.class) {
return (T) Float.valueOf(resultSet.getFloat(columnLabel));
}
if (type == Short.class) {
return (T) Short.valueOf(resultSet.getShort(columnLabel));
}
if (type == BigDecimal.class) {
return (T) resultSet.getBigDecimal(columnLabel);
}
if (type == Byte.class) {
return (T) Byte.valueOf(resultSet.getByte(columnLabel));
}
// Dates
if (type == Date.class) {
return (T) resultSet.getDate(columnLabel);
}
if (type == Time.class) {
return (T) resultSet.getTime(columnLabel);
}
if (type == Timestamp.class) {
return (T) resultSet.getTimestamp(columnLabel);
}
// Streams
if (type == InputStream.class) {
return (T) resultSet.getBinaryStream(columnLabel);
}
if (type == Reader.class) {
return (T) resultSet.getCharacterStream(columnLabel);
}
// Other
if (type == Object.class) {
return (T) resultSet.getObject(columnLabel);
}
if (type == Boolean.class) {
return (T) Boolean.valueOf(resultSet.getBoolean(columnLabel));
}
if (type == Array.class) {
return (T) resultSet.getArray(columnLabel);
}
if (type == Blob.class) {
return (T) resultSet.getBlob(columnLabel);
}
if (type == Clob.class) {
return (T) resultSet.getClob(columnLabel);
}
if (type == Ref.class) {
return (T) resultSet.getRef(columnLabel);
}
if (type == RowId.class) {
return (T) resultSet.getRowId(columnLabel);
}
if (type == SQLXML.class) {
return (T) resultSet.getSQLXML(columnLabel);
}
if (type == URL.class) {
return (T) resultSet.getURL(columnLabel);
}
throw new SQLFeatureNotSupportedException(
String.format("resultSet=%s, columnLabel=%s, type=%s", resultSet, columnLabel, type));
}
}
/**
* Delegates to {@link CommonDataSource#getParentLogger()} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link CommonDataSource#getParentLogger()}, then return null.
*
*
* @param commonDataSource
* See {@link CommonDataSource#getParentLogger()}
* @return See {@link CommonDataSource#getParentLogger()}
* @throws SQLFeatureNotSupportedException
* See {@link CommonDataSource#getParentLogger()}
*/
public static Logger getParentLogger(final CommonDataSource commonDataSource) throws SQLFeatureNotSupportedException {
try {
return commonDataSource.getParentLogger();
} catch (final AbstractMethodError e) {
throw new SQLFeatureNotSupportedException("javax.sql.CommonDataSource#getParentLogger()");
}
}
/**
* Delegates to {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)} without throwing a
* {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)},
* then return null.
*
*
* @param databaseMetaData
* the receiver
* @param catalog
* See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
* @param schemaPattern
* See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
* @param tableNamePattern
* See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
* @param columnNamePattern
* See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
* @return See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
* @throws SQLException
* See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
* @see DatabaseMetaData#getPseudoColumns(String, String, String, String)
*/
public static ResultSet getPseudoColumns(final DatabaseMetaData databaseMetaData, final String catalog,
final String schemaPattern, final String tableNamePattern, final String columnNamePattern)
throws SQLException {
try {
return databaseMetaData.getPseudoColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern);
} catch (final AbstractMethodError e) {
// do nothing
return null;
}
}
/**
* Delegates to {@link Connection#getSchema()} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link Connection#getSchema()}, then return null.
*
*
* @param connection
* the receiver
* @return null for a JDBC 4 driver or a value per {@link Connection#getSchema()}.
* @throws SQLException
* See {@link Connection#getSchema()}.
* @see Connection#getSchema()
*/
public static String getSchema(final Connection connection) throws SQLException {
try {
return connection.getSchema();
} catch (final AbstractMethodError e) {
// do nothing
return null;
}
}
/**
* Delegates to {@link Statement#isCloseOnCompletion()} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link Statement#isCloseOnCompletion()}, then just check that the
* connection is closed to then throw an SQLException.
*
*
* @param statement
* See {@link Statement#isCloseOnCompletion()}
* @return See {@link Statement#isCloseOnCompletion()}
* @throws SQLException
* See {@link Statement#isCloseOnCompletion()}
* @see Statement#closeOnCompletion()
*/
public static boolean isCloseOnCompletion(final Statement statement) throws SQLException {
try {
return statement.isCloseOnCompletion();
} catch (final AbstractMethodError e) {
if (statement.isClosed()) {
throw new SQLException("Statement closed");
}
return false;
}
}
/**
* Delegates to {@link Connection#setNetworkTimeout(Executor, int)} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link Connection#setNetworkTimeout(Executor, int)}, then do nothing.
*
*
* @param connection
* the receiver
* @param executor
* See {@link Connection#setNetworkTimeout(Executor, int)}
* @param milliseconds
* {@link Connection#setNetworkTimeout(Executor, int)}
* @throws SQLException
* {@link Connection#setNetworkTimeout(Executor, int)}
* @see Connection#setNetworkTimeout(Executor, int)
*/
public static void setNetworkTimeout(final Connection connection, final Executor executor, final int milliseconds)
throws SQLException {
try {
connection.setNetworkTimeout(executor, milliseconds);
} catch (final AbstractMethodError ignored) {
// do nothing
}
}
/**
* Delegates to {@link Connection#setSchema(String)} without throwing an {@link AbstractMethodError}.
*
* If the JDBC driver does not implement {@link Connection#setSchema(String)}, then do nothing.
*
*
* @param connection
* the receiver
* @param schema
* See {@link Connection#setSchema(String)}.
* @throws SQLException
* See {@link Connection#setSchema(String)}.
* @see Connection#setSchema(String)
*/
public static void setSchema(final Connection connection, final String schema) throws SQLException {
try {
connection.setSchema(schema);
} catch (final AbstractMethodError ignored) {
// do nothing
}
}
}
LifetimeExceededException.java 0000664 0000000 0000000 00000002676 14473117325 0034275 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.SQLException;
/**
* Exception thrown when a connection's maximum lifetime has been exceeded.
*
* @since 2.1
*/
final class LifetimeExceededException extends SQLException {
private static final long serialVersionUID = -3783783104516492659L;
/**
* Constructs a new instance.
*/
public LifetimeExceededException() {
}
/**
* Constructs a new instance with the given message.
*
* @param reason a description of the exception
*/
public LifetimeExceededException(final String reason) {
super(reason);
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/ListException.java 0000664 0000000 0000000 00000003507 14473117325 0032074 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.util.List;
/**
* An exception wrapping a list of exceptions.
*
* @since 2.4.0
*/
public class ListException extends Exception {
private static final long serialVersionUID = 1L;
private final List exceptionList;
/**
* Constructs a new exception with the specified detail message. The cause is not initialized, and may subsequently
* be initialized by a call to {@link #initCause}.
*
* @param message
* the detail message. The detail message is saved for later retrieval by the {@link #getMessage()}
* method.
* @param exceptionList
* a list of exceptions.
*/
public ListException(final String message, final List exceptionList) {
super(message);
this.exceptionList = exceptionList;
}
/**
* Gets the list of exceptions.
*
* @return the list of exceptions.
*/
public List getExceptionList() {
return exceptionList;
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/ObjectNameWrapper.java 0000664 0000000 0000000 00000006535 14473117325 0032656 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.lang.management.ManagementFactory;
import java.util.Objects;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Internal wrapper class that allows JMX to be a noop if absent or disabled.
*
* @since 2.2.1
*/
final class ObjectNameWrapper {
private static final Log log = LogFactory.getLog(ObjectNameWrapper.class);
private static final MBeanServer MBEAN_SERVER = getPlatformMBeanServer();
private static MBeanServer getPlatformMBeanServer() {
try {
return ManagementFactory.getPlatformMBeanServer();
} catch (final LinkageError | Exception e) {
// ignore - JMX not available
log.debug("Failed to get platform MBeanServer", e);
return null;
}
}
public static ObjectName unwrap(final ObjectNameWrapper wrapper) {
return wrapper == null ? null : wrapper.unwrap();
}
public static ObjectNameWrapper wrap(final ObjectName objectName) {
return new ObjectNameWrapper(objectName);
}
public static ObjectNameWrapper wrap(final String name) throws MalformedObjectNameException {
return wrap(new ObjectName(name));
}
private final ObjectName objectName;
public ObjectNameWrapper(final ObjectName objectName) {
this.objectName = objectName;
}
public void registerMBean(final Object object) {
if (MBEAN_SERVER == null || objectName == null) {
return;
}
try {
MBEAN_SERVER.registerMBean(object, objectName);
} catch (final LinkageError | Exception e) {
log.warn("Failed to complete JMX registration for " + objectName, e);
}
}
/**
* @since 2.7.0
*/
@Override
public String toString() {
return Objects.toString(objectName);
}
public void unregisterMBean() {
if (MBEAN_SERVER == null || objectName == null) {
return;
}
if (MBEAN_SERVER.isRegistered(objectName)) {
try {
MBEAN_SERVER.unregisterMBean(objectName);
} catch (final LinkageError | Exception e) {
log.warn("Failed to complete JMX unregistration for " + objectName, e);
}
}
}
public ObjectName unwrap() {
return objectName;
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/PStmtKey.java 0000664 0000000 0000000 00000070407 14473117325 0031025 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;
import java.util.Objects;
import java.util.function.Function;
import org.apache.commons.dbcp2.PoolingConnection.StatementType;
/**
* A key uniquely identifying {@link java.sql.PreparedStatement PreparedStatement}s.
*
* @since 2.0
*/
public class PStmtKey {
/**
* Interface for Prepared or Callable Statement.
*/
@FunctionalInterface
private interface StatementBuilder {
Statement createStatement(Connection connection, PStmtKey key) throws SQLException;
}
private static final StatementBuilder CallConcurrency = (c, k) -> c.prepareCall(k.sql, k.resultSetType, k.resultSetConcurrency);
private static final StatementBuilder CallHoldability = (c, k) -> c.prepareCall(k.sql, k.resultSetType, k.resultSetConcurrency, k.resultSetHoldability);
private static final StatementBuilder CallSQL = (c, k) -> c.prepareCall(k.sql);
private static final StatementBuilder StatementAutoGeneratedKeys = (c, k) -> c.prepareStatement(k.sql, k.autoGeneratedKeys);
private static final StatementBuilder StatementColumnIndexes = (c, k) -> c.prepareStatement(k.sql, k.columnIndexes);
private static final StatementBuilder StatementColumnNames = (c, k) -> c.prepareStatement(k.sql, k.columnNames);
private static final StatementBuilder StatementConcurrency = (c, k) -> c.prepareStatement(k.sql, k.resultSetType, k.resultSetConcurrency);
private static final StatementBuilder StatementHoldability = (c, k) -> c.prepareStatement(k.sql, k.resultSetType, k.resultSetConcurrency,
k.resultSetHoldability);
private static final StatementBuilder StatementSQL = (c, k) -> c.prepareStatement(k.sql);
private static StatementBuilder match(final StatementType statementType, final StatementBuilder prep, final StatementBuilder call) {
switch (Objects.requireNonNull(statementType, "statementType")) {
case PREPARED_STATEMENT:
return prep;
case CALLABLE_STATEMENT:
return call;
default:
throw new IllegalArgumentException(statementType.toString());
}
}
/**
* SQL defining Prepared or Callable Statement
*/
private final String sql;
/**
* Result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY}, {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or
* {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
*/
private final Integer resultSetType;
/**
* Result set concurrency. A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
*/
private final Integer resultSetConcurrency;
/**
* Result set holdability. One of the following {@code ResultSet} constants: {@code ResultSet.HOLD_CURSORS_OVER_COMMIT}
* or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
*/
private final Integer resultSetHoldability;
/**
* Database catalog.
*/
private final String catalog;
/**
* Database schema.
*/
private final String schema;
/**
* A flag indicating whether auto-generated keys should be returned; one of {@code Statement.RETURN_GENERATED_KEYS} or
* {@code Statement.NO_GENERATED_KEYS}.
*/
private final Integer autoGeneratedKeys;
/**
* An array of column indexes indicating the columns that should be returned from the inserted row or rows.
*/
private final int[] columnIndexes;
/**
* An array of column names indicating the columns that should be returned from the inserted row or rows.
*/
private final String[] columnNames;
/**
* Statement builder.
*/
private final transient StatementBuilder statementBuilder;
/**
* Statement type, prepared or callable.
*/
private final StatementType statementType;
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @deprecated Use {@link #PStmtKey(String, String, String)}.
*/
@Deprecated
public PStmtKey(final String sql) {
this(sql, null, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param resultSetType A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @deprecated Use {@link #PStmtKey(String, String, String, int, int)}.
*/
@Deprecated
public PStmtKey(final String sql, final int resultSetType, final int resultSetConcurrency) {
this(sql, null, resultSetType, resultSetConcurrency, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @deprecated Use {@link #PStmtKey(String, String, String)}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog) {
this(sql, catalog, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param autoGeneratedKeys A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
* @deprecated Use {@link #PStmtKey(String, String, String, int)}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final int autoGeneratedKeys) {
this(sql, catalog, StatementType.PREPARED_STATEMENT, autoGeneratedKeys);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param resultSetType A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @deprecated Use {@link #PStmtKey(String, String, String, int, int)}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final int resultSetType, final int resultSetConcurrency) {
this(sql, catalog, resultSetType, resultSetConcurrency, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param resultSetType a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}
* @param resultSetHoldability One of the following {@code ResultSet} constants:
* {@code ResultSet.HOLD_CURSORS_OVER_COMMIT} or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @deprecated Use {@link #PStmtKey(String, String, String, int, int, int)}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) {
this(sql, catalog, resultSetType, resultSetConcurrency, resultSetHoldability, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param resultSetType a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param resultSetHoldability One of the following {@code ResultSet} constants:
* {@code ResultSet.HOLD_CURSORS_OVER_COMMIT} or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @param statementType The SQL statement type, prepared or callable.
* @deprecated Use {@link #PStmtKey(String, String, String, int, int, int, PoolingConnection.StatementType)}
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability,
final StatementType statementType) {
this(sql, catalog, null, resultSetType, resultSetConcurrency, resultSetHoldability, null, null, null, statementType,
k -> match(statementType, StatementHoldability, CallHoldability));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param resultSetType A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param statementType The SQL statement type, prepared or callable.
* @deprecated Use {@link #PStmtKey(String, String, String, int, int, PoolingConnection.StatementType)}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final int resultSetType, final int resultSetConcurrency, final StatementType statementType) {
this(sql, catalog, null, resultSetType, resultSetConcurrency, null, null, null, null, statementType,
k -> match(statementType, StatementConcurrency, CallConcurrency));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param columnIndexes An array of column indexes indicating the columns that should be returned from the inserted row
* or rows.
* @deprecated Use {@link #PStmtKey(String, String, String, int[])}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final int[] columnIndexes) {
this(sql, catalog, null, null, null, null, null, columnIndexes, null, StatementType.PREPARED_STATEMENT, StatementColumnIndexes);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param statementType The SQL statement type, prepared or callable.
* @deprecated Use {@link #PStmtKey(String, String, String, PoolingConnection.StatementType)}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final StatementType statementType) {
this(sql, catalog, null, null, null, null, null, null, null, statementType, k -> match(statementType, StatementSQL, CallSQL));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param statementType The SQL statement type, prepared or callable.
* @param autoGeneratedKeys A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
* @deprecated Use {@link #PStmtKey(String, String, String, PoolingConnection.StatementType, Integer)}
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final StatementType statementType, final Integer autoGeneratedKeys) {
this(sql, catalog, null, null, null, null, autoGeneratedKeys, null, null, statementType,
k -> match(statementType, StatementAutoGeneratedKeys, CallSQL));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema) {
this(sql, catalog, schema, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema
* @param autoGeneratedKeys A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema, final int autoGeneratedKeys) {
this(sql, catalog, schema, StatementType.PREPARED_STATEMENT, autoGeneratedKeys);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema
* @param resultSetType A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
*/
public PStmtKey(final String sql, final String catalog, final String schema, final int resultSetType, final int resultSetConcurrency) {
this(sql, catalog, schema, resultSetType, resultSetConcurrency, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema
* @param resultSetType a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}
* @param resultSetHoldability One of the following {@code ResultSet} constants:
* {@code ResultSet.HOLD_CURSORS_OVER_COMMIT} or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) {
this(sql, catalog, schema, resultSetType, resultSetConcurrency, resultSetHoldability, StatementType.PREPARED_STATEMENT);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema.
* @param resultSetType a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param resultSetHoldability One of the following {@code ResultSet} constants:
* {@code ResultSet.HOLD_CURSORS_OVER_COMMIT} or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @param statementType The SQL statement type, prepared or callable.
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability, final StatementType statementType) {
this(sql, catalog, schema, resultSetType, resultSetConcurrency, resultSetHoldability, null, null, null, statementType,
k -> match(statementType, StatementHoldability, CallHoldability));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema.
* @param resultSetType A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param statementType The SQL statement type, prepared or callable.
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema, final int resultSetType, final int resultSetConcurrency,
final StatementType statementType) {
this(sql, catalog, schema, resultSetType, resultSetConcurrency, null, null, null, null, statementType,
k -> match(statementType, StatementConcurrency, CallConcurrency));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema.
* @param columnIndexes An array of column indexes indicating the columns that should be returned from the inserted row
* or rows.
*/
public PStmtKey(final String sql, final String catalog, final String schema, final int[] columnIndexes) {
this(sql, catalog, schema, null, null, null, null, columnIndexes, null, StatementType.PREPARED_STATEMENT, StatementColumnIndexes);
}
private PStmtKey(final String sql, final String catalog, final String schema, final Integer resultSetType, final Integer resultSetConcurrency,
final Integer resultSetHoldability, final Integer autoGeneratedKeys, final int[] columnIndexes, final String[] columnNames,
final StatementType statementType, final Function statementBuilder) {
this.sql = Objects.requireNonNull(sql, "sql").trim();
this.catalog = catalog;
this.schema = schema;
this.resultSetType = resultSetType;
this.resultSetConcurrency = resultSetConcurrency;
this.resultSetHoldability = resultSetHoldability;
this.autoGeneratedKeys = autoGeneratedKeys;
this.columnIndexes = clone(columnIndexes);
this.columnNames = clone(columnNames);
this.statementBuilder = Objects.requireNonNull(Objects.requireNonNull(statementBuilder, "statementBuilder").apply(this), "statementBuilder");
this.statementType = statementType;
}
// Root constructor.
private PStmtKey(final String sql, final String catalog, final String schema, final Integer resultSetType, final Integer resultSetConcurrency,
final Integer resultSetHoldability, final Integer autoGeneratedKeys, final int[] columnIndexes, final String[] columnNames,
final StatementType statementType, final StatementBuilder statementBuilder) {
this.sql = sql;
this.catalog = catalog;
this.schema = schema;
this.resultSetType = resultSetType;
this.resultSetConcurrency = resultSetConcurrency;
this.resultSetHoldability = resultSetHoldability;
this.autoGeneratedKeys = autoGeneratedKeys;
this.columnIndexes = clone(columnIndexes);
this.columnNames = clone(columnNames);
this.statementBuilder = Objects.requireNonNull(statementBuilder, "statementBuilder");
this.statementType = statementType;
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema.
* @param statementType The SQL statement type, prepared or callable.
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema, final StatementType statementType) {
this(sql, catalog, schema, null, null, null, null, null, null, statementType, k -> match(statementType, StatementSQL, CallSQL));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema.
* @param statementType The SQL statement type, prepared or callable.
* @param autoGeneratedKeys A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema, final StatementType statementType, final Integer autoGeneratedKeys) {
this(sql, catalog, schema, null, null, null, autoGeneratedKeys, null, null, statementType,
k -> match(statementType, StatementAutoGeneratedKeys, CallSQL));
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param schema The schema.
* @param columnNames An array of column names indicating the columns that should be returned from the inserted row or
* rows.
* @since 2.5.0
*/
public PStmtKey(final String sql, final String catalog, final String schema, final String[] columnNames) {
this(sql, catalog, schema, null, null, null, null, null, columnNames, StatementType.PREPARED_STATEMENT, StatementColumnNames);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql The SQL statement.
* @param catalog The catalog.
* @param columnNames An array of column names indicating the columns that should be returned from the inserted row or
* rows.
* @deprecated Use {@link #PStmtKey(String, String, String, String[])}.
*/
@Deprecated
public PStmtKey(final String sql, final String catalog, final String[] columnNames) {
this(sql, catalog, null, null, null, null, null, null, columnNames, StatementType.PREPARED_STATEMENT, StatementColumnNames);
}
private int[] clone(final int[] array) {
return array == null ? null : array.clone();
}
private String[] clone(final String[] array) {
return array == null ? null : array.clone();
}
/**
* Creates a new Statement from the given Connection.
*
* @param connection The Connection to use to create the statement.
* @return The statement.
* @throws SQLException Thrown when there is a problem creating the statement.
*/
public Statement createStatement(final Connection connection) throws SQLException {
return statementBuilder.createStatement(connection, this);
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final PStmtKey other = (PStmtKey) obj;
if (!Objects.equals(autoGeneratedKeys, other.autoGeneratedKeys)) {
return false;
}
if (!Objects.equals(catalog, other.catalog)) {
return false;
}
if (!Arrays.equals(columnIndexes, other.columnIndexes)) {
return false;
}
if (!Arrays.equals(columnNames, other.columnNames)) {
return false;
}
if (!Objects.equals(resultSetConcurrency, other.resultSetConcurrency)) {
return false;
}
if (!Objects.equals(resultSetHoldability, other.resultSetHoldability)) {
return false;
}
if (!Objects.equals(resultSetType, other.resultSetType)) {
return false;
}
if (!Objects.equals(schema, other.schema)) {
return false;
}
if (!Objects.equals(sql, other.sql)) {
return false;
}
return statementType == other.statementType;
}
/**
* Gets a flag indicating whether auto-generated keys should be returned; one of {@code Statement.RETURN_GENERATED_KEYS}
* or {@code Statement.NO_GENERATED_KEYS}.
*
* @return a flag indicating whether auto-generated keys should be returned.
*/
public Integer getAutoGeneratedKeys() {
return autoGeneratedKeys;
}
/**
* Gets the catalog.
*
* @return The catalog.
*/
public String getCatalog() {
return catalog;
}
/**
* Gets an array of column indexes indicating the columns that should be returned from the inserted row or rows.
*
* @return An array of column indexes.
*/
public int[] getColumnIndexes() {
return clone(columnIndexes);
}
/**
* Gets an array of column names indicating the columns that should be returned from the inserted row or rows.
*
* @return An array of column names.
*/
public String[] getColumnNames() {
return clone(columnNames);
}
/**
* Gets the result set concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
*
* @return The result set concurrency type.
*/
public Integer getResultSetConcurrency() {
return resultSetConcurrency;
}
/**
* Gets the result set holdability, one of the following {@code ResultSet} constants:
* {@code ResultSet.HOLD_CURSORS_OVER_COMMIT} or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
*
* @return The result set holdability.
*/
public Integer getResultSetHoldability() {
return resultSetHoldability;
}
/**
* Gets the result set type, one of {@code ResultSet.TYPE_FORWARD_ONLY}, {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or
* {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
*
* @return the result set type.
*/
public Integer getResultSetType() {
return resultSetType;
}
/**
* Gets the schema.
*
* @return The catalog.
*/
public String getSchema() {
return schema;
}
/**
* Gets the SQL statement.
*
* @return the SQL statement.
*/
public String getSql() {
return sql;
}
/**
* Gets the SQL statement type.
*
* @return The SQL statement type.
*/
public StatementType getStmtType() {
return statementType;
}
@Override
public int hashCode() {
return Objects.hash(autoGeneratedKeys, catalog, Arrays.hashCode(columnIndexes), Arrays.hashCode(columnNames), resultSetConcurrency,
resultSetHoldability, resultSetType, schema, sql, statementType);
}
@Override
public String toString() {
final StringBuilder buf = new StringBuilder();
buf.append("PStmtKey: sql=");
buf.append(sql);
buf.append(", catalog=");
buf.append(catalog);
buf.append(", schema=");
buf.append(schema);
buf.append(", resultSetType=");
buf.append(resultSetType);
buf.append(", resultSetConcurrency=");
buf.append(resultSetConcurrency);
buf.append(", resultSetHoldability=");
buf.append(resultSetHoldability);
buf.append(", autoGeneratedKeys=");
buf.append(autoGeneratedKeys);
buf.append(", columnIndexes=");
buf.append(Arrays.toString(columnIndexes));
buf.append(", columnNames=");
buf.append(Arrays.toString(columnNames));
buf.append(", statementType=");
buf.append(statementType);
return buf.toString();
}
}
PoolableCallableStatement.java 0000664 0000000 0000000 00000007567 14473117325 0034277 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.SQLException;
import org.apache.commons.pool2.KeyedObjectPool;
/**
* A {@link DelegatingCallableStatement} that cooperates with {@link PoolingConnection} to implement a pool of
* {@link CallableStatement}s.
*
* The {@link #close} method returns this statement to its containing pool. (See {@link PoolingConnection}.)
*
* @see PoolingConnection
* @since 2.0
*/
public class PoolableCallableStatement extends DelegatingCallableStatement {
/**
* The {@link KeyedObjectPool} from which this CallableStatement was obtained.
*/
private final KeyedObjectPool pool;
/**
* Key for this statement in the containing {@link KeyedObjectPool}.
*/
private final PStmtKey key;
/**
* Constructor.
*
* @param callableStatement
* the underlying {@link CallableStatement}
* @param key
* the key for this statement in the {@link KeyedObjectPool}
* @param pool
* the {@link KeyedObjectPool} from which this CallableStatement was obtained
* @param connection
* the {@link DelegatingConnection} that created this CallableStatement
*/
public PoolableCallableStatement(final CallableStatement callableStatement, final PStmtKey key,
final KeyedObjectPool pool,
final DelegatingConnection connection) {
super(connection, callableStatement);
this.pool = pool;
this.key = key;
// Remove from trace now because this statement will be
// added by the activate method.
removeThisTrace(connection);
}
/**
* Activates after retrieval from the pool. Adds a trace for this CallableStatement to the Connection that created
* it.
*
* @since 2.4.0 made public, was protected in 2.3.0.
*/
@Override
public void activate() throws SQLException {
setClosedInternal(false);
AbandonedTrace.add(getConnectionInternal(), this);
super.activate();
}
/**
* Returns the CallableStatement to the pool. If {{@link #isClosed()}, this is a No-op.
*/
@Override
public void close() throws SQLException {
// calling close twice should have no effect
if (!isClosed()) {
try {
pool.returnObject(key, this);
} catch (final SQLException | RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Cannot close CallableStatement (return to pool failed)", e);
}
}
}
/**
* Passivates to prepare for return to the pool. Removes the trace associated with this CallableStatement from the
* Connection that created it. Also closes any associated ResultSets.
*
* @since 2.4.0 made public, was protected in 2.3.0.
*/
@Override
public void passivate() throws SQLException {
prepareToReturn();
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/PoolableConnection.java 0000664 0000000 0000000 00000037250 14473117325 0033061 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.lang.management.ManagementFactory;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.Duration;
import java.util.Collection;
import java.util.concurrent.Executor;
import javax.management.InstanceAlreadyExistsException;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
import org.apache.commons.pool2.ObjectPool;
/**
* A delegating connection that, rather than closing the underlying connection, returns itself to an {@link ObjectPool}
* when closed.
*
* @since 2.0
*/
public class PoolableConnection extends DelegatingConnection implements PoolableConnectionMXBean {
private static MBeanServer MBEAN_SERVER;
static {
try {
MBEAN_SERVER = ManagementFactory.getPlatformMBeanServer();
} catch (final NoClassDefFoundError | Exception ignored) {
// ignore - JMX not available
}
}
/** The pool to which I should return. */
private final ObjectPool pool;
private final ObjectNameWrapper jmxObjectName;
// Use a prepared statement for validation, retaining the last used SQL to
// check if the validation query has changed.
private PreparedStatement validationPreparedStatement;
private String lastValidationSql;
/**
* Indicate that unrecoverable SQLException was thrown when using this connection. Such a connection should be
* considered broken and not pass validation in the future.
*/
private boolean fatalSqlExceptionThrown;
/**
* SQL_STATE codes considered to signal fatal conditions. Overrides the defaults in
* {@link Utils#getDisconnectionSqlCodes()} (plus anything starting with {@link Utils#DISCONNECTION_SQL_CODE_PREFIX}).
*/
private final Collection disconnectionSqlCodes;
/** Whether or not to fast fail validation after fatal connection errors */
private final boolean fastFailValidation;
/**
*
* @param conn
* my underlying connection
* @param pool
* the pool to which I should return when closed
* @param jmxName
* JMX name
*/
public PoolableConnection(final Connection conn, final ObjectPool pool,
final ObjectName jmxName) {
this(conn, pool, jmxName, null, true);
}
/**
*
* @param conn
* my underlying connection
* @param pool
* the pool to which I should return when closed
* @param jmxObjectName
* JMX name
* @param disconnectSqlCodes
* SQL_STATE codes considered fatal disconnection errors
* @param fastFailValidation
* true means fatal disconnection errors cause subsequent validations to fail immediately (no attempt to
* run query or isValid)
*/
public PoolableConnection(final Connection conn, final ObjectPool pool,
final ObjectName jmxObjectName, final Collection disconnectSqlCodes,
final boolean fastFailValidation) {
super(conn);
this.pool = pool;
this.jmxObjectName = ObjectNameWrapper.wrap(jmxObjectName);
this.disconnectionSqlCodes = disconnectSqlCodes;
this.fastFailValidation = fastFailValidation;
if (jmxObjectName != null) {
try {
MBEAN_SERVER.registerMBean(this, jmxObjectName);
} catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException ignored) {
// For now, simply skip registration
}
}
}
/**
* Abort my underlying {@link Connection}.
*
* @since 2.9.0
*/
@Override
public void abort(final Executor executor) throws SQLException {
if (jmxObjectName != null) {
jmxObjectName.unregisterMBean();
}
super.abort(executor);
}
/**
* Returns me to my pool.
*/
@Override
public synchronized void close() throws SQLException {
if (isClosedInternal()) {
// already closed
return;
}
boolean isUnderlyingConnectionClosed;
try {
isUnderlyingConnectionClosed = getDelegateInternal().isClosed();
} catch (final SQLException e) {
try {
pool.invalidateObject(this);
} catch (final IllegalStateException ise) {
// pool is closed, so close the connection
passivate();
getInnermostDelegate().close();
} catch (final Exception ignored) {
// DO NOTHING the original exception will be rethrown
}
throw new SQLException("Cannot close connection (isClosed check failed)", e);
}
/*
* Can't set close before this code block since the connection needs to be open when validation runs. Can't set
* close after this code block since by then the connection will have been returned to the pool and may have
* been borrowed by another thread. Therefore, the close flag is set in passivate().
*/
if (isUnderlyingConnectionClosed) {
// Abnormal close: underlying connection closed unexpectedly, so we
// must destroy this proxy
try {
pool.invalidateObject(this);
} catch (final IllegalStateException e) {
// pool is closed, so close the connection
passivate();
getInnermostDelegate().close();
} catch (final Exception e) {
throw new SQLException("Cannot close connection (invalidating pooled object failed)", e);
}
} else {
// Normal close: underlying connection is still open, so we
// simply need to return this proxy to the pool
try {
pool.returnObject(this);
} catch (final IllegalStateException e) {
// pool is closed, so close the connection
passivate();
getInnermostDelegate().close();
} catch (final SQLException | RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Cannot close connection (return to pool failed)", e);
}
}
}
/**
* @return The disconnection SQL codes.
* @since 2.6.0
*/
public Collection getDisconnectionSqlCodes() {
return disconnectionSqlCodes;
}
/**
* Expose the {@link #toString()} method via a bean getter, so it can be read as a property via JMX.
*/
@Override
public String getToString() {
return toString();
}
@Override
protected void handleException(final SQLException e) throws SQLException {
fatalSqlExceptionThrown |= isFatalException(e);
super.handleException(e);
}
/**
* {@inheritDoc}
*
* This method should not be used by a client to determine whether or not a connection should be return to the
* connection pool (by calling {@link #close()}). Clients should always attempt to return a connection to the pool
* once it is no longer required.
*/
@Override
public boolean isClosed() throws SQLException {
if (isClosedInternal()) {
return true;
}
if (getDelegateInternal().isClosed()) {
// Something has gone wrong. The underlying connection has been
// closed without the connection being returned to the pool. Return
// it now.
close();
return true;
}
return false;
}
/**
* Checks the SQLState of the input exception.
*
* If {@link #disconnectionSqlCodes} has been set, sql states are compared to those in the configured list of fatal
* exception codes. If this property is not set, codes are compared against the default codes in
* {@link Utils#getDisconnectionSqlCodes()} and in this case anything starting with #{link
* Utils.DISCONNECTION_SQL_CODE_PREFIX} is considered a disconnection.
*
*
* @param e SQLException to be examined
* @return true if the exception signals a disconnection
*/
boolean isDisconnectionSqlException(final SQLException e) {
boolean fatalException = false;
final String sqlState = e.getSQLState();
if (sqlState != null) {
fatalException = disconnectionSqlCodes == null
? sqlState.startsWith(Utils.DISCONNECTION_SQL_CODE_PREFIX) || Utils.getDisconnectionSqlCodes().contains(sqlState)
: disconnectionSqlCodes.contains(sqlState);
}
return fatalException;
}
/**
* Checks the SQLState of the input exception and any nested SQLExceptions it wraps.
*
* If {@link #disconnectionSqlCodes} has been set, sql states are compared to those in the
* configured list of fatal exception codes. If this property is not set, codes are compared against the default
* codes in {@link Utils#getDisconnectionSqlCodes()} and in this case anything starting with #{link
* Utils.DISCONNECTION_SQL_CODE_PREFIX} is considered a disconnection.
*
*
* @param e
* SQLException to be examined
* @return true if the exception signals a disconnection
*/
boolean isFatalException(final SQLException e) {
boolean fatalException = isDisconnectionSqlException(e);
if (!fatalException) {
SQLException parentException = e;
SQLException nextException = e.getNextException();
while (nextException != null && nextException != parentException && !fatalException) {
fatalException = isDisconnectionSqlException(nextException);
parentException = nextException;
nextException = parentException.getNextException();
}
}
return fatalException;
}
/**
* @return Whether to fail-fast.
* @since 2.6.0
*/
public boolean isFastFailValidation() {
return fastFailValidation;
}
@Override
protected void passivate() throws SQLException {
super.passivate();
setClosedInternal(true);
if (getDelegateInternal() instanceof PoolingConnection) {
((PoolingConnection) getDelegateInternal()).connectionReturnedToPool();
}
}
/**
* Actually close my underlying {@link Connection}.
*/
@Override
public void reallyClose() throws SQLException {
if (jmxObjectName != null) {
jmxObjectName.unregisterMBean();
}
if (validationPreparedStatement != null) {
Utils.closeQuietly((AutoCloseable) validationPreparedStatement);
}
super.closeInternal();
}
/**
* Validates the connection, using the following algorithm:
*
* - If {@code fastFailValidation} (constructor argument) is {@code true} and this connection has previously
* thrown a fatal disconnection exception, a {@code SQLException} is thrown.
* - If {@code sql} is null, the driver's #{@link Connection#isValid(int) isValid(timeout)} is called. If it
* returns {@code false}, {@code SQLException} is thrown; otherwise, this method returns successfully.
* - If {@code sql} is not null, it is executed as a query and if the resulting {@code ResultSet} contains at
* least one row, this method returns successfully. If not, {@code SQLException} is thrown.
*
*
* @param sql
* The validation SQL query.
* @param timeoutSeconds
* The validation timeout in seconds.
* @throws SQLException
* Thrown when validation fails or an SQLException occurs during validation
* @deprecated Use {@link #validate(String, Duration)}.
*/
@Deprecated
public void validate(final String sql, final int timeoutSeconds) throws SQLException {
validate(sql, Duration.ofSeconds(timeoutSeconds));
}
/**
* Validates the connection, using the following algorithm:
*
* - If {@code fastFailValidation} (constructor argument) is {@code true} and this connection has previously
* thrown a fatal disconnection exception, a {@code SQLException} is thrown.
* - If {@code sql} is null, the driver's #{@link Connection#isValid(int) isValid(timeout)} is called. If it
* returns {@code false}, {@code SQLException} is thrown; otherwise, this method returns successfully.
* - If {@code sql} is not null, it is executed as a query and if the resulting {@code ResultSet} contains at
* least one row, this method returns successfully. If not, {@code SQLException} is thrown.
*
*
* @param sql
* The validation SQL query.
* @param timeoutDuration
* The validation timeout in seconds.
* @throws SQLException
* Thrown when validation fails or an SQLException occurs during validation
* @since 2.10.0
*/
public void validate(final String sql, Duration timeoutDuration) throws SQLException {
if (fastFailValidation && fatalSqlExceptionThrown) {
throw new SQLException(Utils.getMessage("poolableConnection.validate.fastFail"));
}
if (sql == null || sql.isEmpty()) {
if (timeoutDuration.isNegative()) {
timeoutDuration = Duration.ZERO;
}
if (!isValid(timeoutDuration)) {
throw new SQLException("isValid() returned false");
}
return;
}
if (!sql.equals(lastValidationSql)) {
lastValidationSql = sql;
// Has to be the innermost delegate else the prepared statement will
// be closed when the pooled connection is passivated.
validationPreparedStatement = getInnermostDelegateInternal().prepareStatement(sql);
}
if (timeoutDuration.compareTo(Duration.ZERO) > 0) {
validationPreparedStatement.setQueryTimeout((int) timeoutDuration.getSeconds());
}
try (ResultSet rs = validationPreparedStatement.executeQuery()) {
if (!rs.next()) {
throw new SQLException("validationQuery didn't return a row");
}
} catch (final SQLException sqle) {
throw sqle;
}
}
}
PoolableConnectionFactory.java 0000664 0000000 0000000 00000063734 14473117325 0034340 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.Duration;
import java.util.Collection;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicLong;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.pool2.DestroyMode;
import org.apache.commons.pool2.KeyedObjectPool;
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
/**
* A {@link PooledObjectFactory} that creates {@link PoolableConnection}s.
*
* @since 2.0
*/
public class PoolableConnectionFactory implements PooledObjectFactory {
private static final Log log = LogFactory.getLog(PoolableConnectionFactory.class);
/**
* Internal constant to indicate the level is not set.
*/
static final int UNKNOWN_TRANSACTION_ISOLATION = -1;
private final ConnectionFactory connectionFactory;
private final ObjectName dataSourceJmxObjectName;
private volatile String validationQuery;
private volatile Duration validationQueryTimeoutDuration = Duration.ofSeconds(-1);
private Collection connectionInitSqls;
private Collection disconnectionSqlCodes;
private boolean fastFailValidation = true;
private volatile ObjectPool pool;
private Boolean defaultReadOnly;
private Boolean defaultAutoCommit;
private boolean autoCommitOnReturn = true;
private boolean rollbackOnReturn = true;
private int defaultTransactionIsolation = UNKNOWN_TRANSACTION_ISOLATION;
private String defaultCatalog;
private String defaultSchema;
private boolean cacheState;
private boolean poolStatements;
private boolean clearStatementPoolOnReturn;
private int maxOpenPreparedStatements = GenericKeyedObjectPoolConfig.DEFAULT_MAX_TOTAL_PER_KEY;
private Duration maxConnDuration = Duration.ofMillis(-1);
private final AtomicLong connectionIndex = new AtomicLong();
private Duration defaultQueryTimeoutDuration;
/**
* Creates a new {@code PoolableConnectionFactory}.
*
* @param connFactory
* the {@link ConnectionFactory} from which to obtain base {@link Connection}s
* @param dataSourceJmxObjectName
* The JMX object name, may be null.
*/
public PoolableConnectionFactory(final ConnectionFactory connFactory, final ObjectName dataSourceJmxObjectName) {
this.connectionFactory = connFactory;
this.dataSourceJmxObjectName = dataSourceJmxObjectName;
}
@Override
public void activateObject(final PooledObject p) throws SQLException {
validateLifetime(p);
final PoolableConnection pConnection = p.getObject();
pConnection.activate();
if (defaultAutoCommit != null && pConnection.getAutoCommit() != defaultAutoCommit) {
pConnection.setAutoCommit(defaultAutoCommit);
}
if (defaultTransactionIsolation != UNKNOWN_TRANSACTION_ISOLATION
&& pConnection.getTransactionIsolation() != defaultTransactionIsolation) {
pConnection.setTransactionIsolation(defaultTransactionIsolation);
}
if (defaultReadOnly != null && pConnection.isReadOnly() != defaultReadOnly) {
pConnection.setReadOnly(defaultReadOnly);
}
if (defaultCatalog != null && !defaultCatalog.equals(pConnection.getCatalog())) {
pConnection.setCatalog(defaultCatalog);
}
if (defaultSchema != null && !defaultSchema.equals(Jdbc41Bridge.getSchema(pConnection))) {
Jdbc41Bridge.setSchema(pConnection, defaultSchema);
}
pConnection.setDefaultQueryTimeout(defaultQueryTimeoutDuration);
}
@Override
public void destroyObject(final PooledObject p) throws SQLException {
p.getObject().reallyClose();
}
/**
* @since 2.9.0
*/
@Override
public void destroyObject(final PooledObject p, final DestroyMode mode) throws SQLException {
if (mode == DestroyMode.ABANDONED) {
p.getObject().getInnermostDelegate().abort(Runnable::run);
} else {
p.getObject().reallyClose();
}
}
/**
* Gets the cache state.
*
* @return The cache state.
* @since 2.6.0.
*/
public boolean getCacheState() {
return cacheState;
}
/**
* Gets the connection factory.
*
* @return The connection factory.
* @since 2.6.0.
*/
public ConnectionFactory getConnectionFactory() {
return connectionFactory;
}
protected AtomicLong getConnectionIndex() {
return connectionIndex;
}
/**
* @return The collection of initialization SQL statements.
* @since 2.6.0
*/
public Collection getConnectionInitSqls() {
return connectionInitSqls;
}
/**
* @return The data source JMX ObjectName
* @since 2.6.0.
*/
public ObjectName getDataSourceJmxName() {
return dataSourceJmxObjectName;
}
/**
* @return The data source JMS ObjectName.
* @since 2.6.0
*/
public ObjectName getDataSourceJmxObjectName() {
return dataSourceJmxObjectName;
}
/**
* @return Default auto-commit value.
* @since 2.6.0
*/
public Boolean getDefaultAutoCommit() {
return defaultAutoCommit;
}
/**
* @return Default catalog.
* @since 2.6.0
*/
public String getDefaultCatalog() {
return defaultCatalog;
}
/**
* @return Default query timeout in seconds.
* @deprecated Use {@link #getDefaultQueryTimeoutDuration()}.
*/
@Deprecated
public Integer getDefaultQueryTimeout() {
return getDefaultQueryTimeoutSeconds();
}
/**
* Gets the default query timeout Duration.
*
* @return Default query timeout Duration.
* @since 2.10.0
*/
public Duration getDefaultQueryTimeoutDuration() {
return defaultQueryTimeoutDuration;
}
/**
* @return Default query timeout in seconds.
* @since 2.6.0
* @deprecated Use {@link #getDefaultQueryTimeoutDuration()}.
*/
@Deprecated
public Integer getDefaultQueryTimeoutSeconds() {
return defaultQueryTimeoutDuration == null ? null : (int) defaultQueryTimeoutDuration.getSeconds();
}
/**
* @return Default read-only-value.
* @since 2.6.0
*/
public Boolean getDefaultReadOnly() {
return defaultReadOnly;
}
/**
* @return Default schema.
* @since 2.6.0
*/
public String getDefaultSchema() {
return defaultSchema;
}
/**
* @return Default transaction isolation.
* @since 2.6.0
*/
public int getDefaultTransactionIsolation() {
return defaultTransactionIsolation;
}
/**
* SQL_STATE codes considered to signal fatal conditions.
*
* Overrides the defaults in {@link Utils#getDisconnectionSqlCodes()} (plus anything starting with
* {@link Utils#DISCONNECTION_SQL_CODE_PREFIX}). If this property is non-null and {@link #isFastFailValidation()} is
* {@code true}, whenever connections created by this factory 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 {@link #isFastFailValidation()} is {@code false} setting this property has no effect.
*
*
* @return SQL_STATE codes overriding defaults
* @since 2.1
*/
public Collection getDisconnectionSqlCodes() {
return disconnectionSqlCodes;
}
/**
* Gets the Maximum connection duration.
*
* @return Maximum connection duration.
* @since 2.10.0
*/
public Duration getMaxConnDuration() {
return maxConnDuration;
}
/**
* Gets the Maximum connection lifetime in milliseconds.
*
* @return Maximum connection lifetime in milliseconds.
* @since 2.6.0
*/
public long getMaxConnLifetimeMillis() {
return maxConnDuration.toMillis();
}
protected int getMaxOpenPreparedStatements() {
return maxOpenPreparedStatements;
}
/**
* Returns the {@link ObjectPool} in which {@link Connection}s are pooled.
*
* @return the connection pool
*/
public synchronized ObjectPool getPool() {
return pool;
}
/**
* @return Whether to pool statements.
* @since 2.6.0.
*/
public boolean getPoolStatements() {
return poolStatements;
}
/**
* @return Validation query.
* @since 2.6.0
*/
public String getValidationQuery() {
return validationQuery;
}
/**
* Gets the query timeout in seconds.
*
* @return Validation query timeout in seconds.
* @since 2.10.0
*/
public Duration getValidationQueryTimeoutDuration() {
return validationQueryTimeoutDuration;
}
/**
* Gets the query timeout in seconds.
*
* @return Validation query timeout in seconds.
* @since 2.6.0
* @deprecated Use {@link #getValidationQueryTimeoutDuration()}.
*/
@Deprecated
public int getValidationQueryTimeoutSeconds() {
return (int) validationQueryTimeoutDuration.getSeconds();
}
protected void initializeConnection(final Connection conn) throws SQLException {
final Collection sqls = connectionInitSqls;
if (conn.isClosed()) {
throw new SQLException("initializeConnection: connection closed");
}
if (!Utils.isEmpty(sqls)) {
try (Statement statement = conn.createStatement()) {
for (final String sql : sqls) {
statement.execute(Objects.requireNonNull(sql, "null connectionInitSqls element"));
}
}
}
}
/**
* @return Whether to auto-commit on return.
* @since 2.6.0
*/
public boolean isAutoCommitOnReturn() {
return autoCommitOnReturn;
}
/**
* @return Whether to auto-commit on return.
* @deprecated Use {@link #isAutoCommitOnReturn()}.
*/
@Deprecated
public boolean isEnableAutoCommitOnReturn() {
return autoCommitOnReturn;
}
/**
* True means that validation will fail immediately for connections that have previously thrown SQLExceptions with
* SQL_STATE indicating fatal disconnection errors.
*
* @return true if connections created by this factory will fast fail validation.
* @see #setDisconnectionSqlCodes(Collection)
* @since 2.1
* @since 2.5.0 Defaults to true, previous versions defaulted to false.
*/
public boolean isFastFailValidation() {
return fastFailValidation;
}
/**
* @return Whether to rollback on return.
*/
public boolean isRollbackOnReturn() {
return rollbackOnReturn;
}
@Override
public PooledObject makeObject() throws SQLException {
Connection conn = connectionFactory.createConnection();
if (conn == null) {
throw new IllegalStateException("Connection factory returned null from createConnection");
}
try {
initializeConnection(conn);
} catch (final SQLException e) {
// Make sure the connection is closed
Utils.closeQuietly((AutoCloseable) conn);
// Rethrow original exception so it is visible to caller
throw e;
}
final long connIndex = connectionIndex.getAndIncrement();
if (poolStatements) {
conn = new PoolingConnection(conn);
final GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig<>();
config.setMaxTotalPerKey(-1);
config.setBlockWhenExhausted(false);
config.setMaxWait(Duration.ZERO);
config.setMaxIdlePerKey(1);
config.setMaxTotal(maxOpenPreparedStatements);
if (dataSourceJmxObjectName != null) {
final StringBuilder base = new StringBuilder(dataSourceJmxObjectName.toString());
base.append(Constants.JMX_CONNECTION_BASE_EXT);
base.append(connIndex);
config.setJmxNameBase(base.toString());
config.setJmxNamePrefix(Constants.JMX_STATEMENT_POOL_PREFIX);
} else {
config.setJmxEnabled(false);
}
final PoolingConnection poolingConn = (PoolingConnection) conn;
final KeyedObjectPool stmtPool = new GenericKeyedObjectPool<>(poolingConn, config);
poolingConn.setStatementPool(stmtPool);
poolingConn.setClearStatementPoolOnReturn(clearStatementPoolOnReturn);
poolingConn.setCacheState(cacheState);
}
// Register this connection with JMX
final ObjectName connJmxName;
if (dataSourceJmxObjectName == null) {
connJmxName = null;
} else {
final String name = dataSourceJmxObjectName.toString() + Constants.JMX_CONNECTION_BASE_EXT + connIndex;
try {
connJmxName = new ObjectName(name);
} catch (MalformedObjectNameException e) {
Utils.closeQuietly((AutoCloseable) conn);
throw new SQLException(name, e);
}
}
final PoolableConnection pc = new PoolableConnection(conn, pool, connJmxName, disconnectionSqlCodes, fastFailValidation);
pc.setCacheState(cacheState);
return new DefaultPooledObject<>(pc);
}
@Override
public void passivateObject(final PooledObject p) throws SQLException {
validateLifetime(p);
final PoolableConnection conn = p.getObject();
Boolean connAutoCommit = null;
if (rollbackOnReturn) {
connAutoCommit = conn.getAutoCommit();
if (!connAutoCommit && !conn.isReadOnly()) {
conn.rollback();
}
}
conn.clearWarnings();
// DBCP-97 / DBCP-399 / DBCP-351 Idle connections in the pool should
// have autoCommit enabled
if (autoCommitOnReturn) {
if (connAutoCommit == null) {
connAutoCommit = conn.getAutoCommit();
}
if (!connAutoCommit) {
conn.setAutoCommit(true);
}
}
conn.passivate();
}
public void setAutoCommitOnReturn(final boolean autoCommitOnReturn) {
this.autoCommitOnReturn = autoCommitOnReturn;
}
public void setCacheState(final boolean cacheState) {
this.cacheState = cacheState;
}
/**
* Sets whether the pool of statements (which was enabled with {@link #setPoolStatements(boolean)}) should
* be cleared when the connection is returned to its pool. Default is false.
*
* @param clearStatementPoolOnReturn clear or not
* @since 2.8.0
*/
public void setClearStatementPoolOnReturn(final boolean clearStatementPoolOnReturn) {
this.clearStatementPoolOnReturn = clearStatementPoolOnReturn;
}
/**
* Sets the SQL statements I use to initialize newly created {@link Connection}s. Using {@code null} turns off
* connection initialization.
*
* @param connectionInitSqls
* SQL statement to initialize {@link Connection}s.
*/
public void setConnectionInitSql(final Collection connectionInitSqls) {
this.connectionInitSqls = connectionInitSqls;
}
/**
* Sets the default "auto commit" setting for borrowed {@link Connection}s
*
* @param defaultAutoCommit
* the default "auto commit" setting for borrowed {@link Connection}s
*/
public void setDefaultAutoCommit(final Boolean defaultAutoCommit) {
this.defaultAutoCommit = defaultAutoCommit;
}
/**
* Sets the default "catalog" setting for borrowed {@link Connection}s
*
* @param defaultCatalog
* the default "catalog" setting for borrowed {@link Connection}s
*/
public void setDefaultCatalog(final String defaultCatalog) {
this.defaultCatalog = defaultCatalog;
}
/**
* Sets the query timeout Duration.
*
* @param defaultQueryTimeoutDuration the query timeout Duration.
* @since 2.10.0
*/
public void setDefaultQueryTimeout(final Duration defaultQueryTimeoutDuration) {
this.defaultQueryTimeoutDuration = defaultQueryTimeoutDuration;
}
/**
* Sets the query timeout in seconds.
*
* @param defaultQueryTimeoutSeconds the query timeout in seconds.
* @deprecated Use {@link #setDefaultQueryTimeout(Duration)}.
*/
@Deprecated
public void setDefaultQueryTimeout(final Integer defaultQueryTimeoutSeconds) {
this.defaultQueryTimeoutDuration = defaultQueryTimeoutSeconds == null ? null : Duration.ofSeconds(defaultQueryTimeoutSeconds);
}
/**
* Sets the default "read only" setting for borrowed {@link Connection}s
*
* @param defaultReadOnly
* the default "read only" setting for borrowed {@link Connection}s
*/
public void setDefaultReadOnly(final Boolean defaultReadOnly) {
this.defaultReadOnly = defaultReadOnly;
}
/**
* Sets the default "schema" setting for borrowed {@link Connection}s
*
* @param defaultSchema
* the default "schema" setting for borrowed {@link Connection}s
* @since 2.5.0
*/
public void setDefaultSchema(final String defaultSchema) {
this.defaultSchema = defaultSchema;
}
/**
* Sets the default "Transaction Isolation" setting for borrowed {@link Connection}s
*
* @param defaultTransactionIsolation
* the default "Transaction Isolation" setting for returned {@link Connection}s
*/
public void setDefaultTransactionIsolation(final int defaultTransactionIsolation) {
this.defaultTransactionIsolation = defaultTransactionIsolation;
}
/**
* @param disconnectionSqlCodes
* The disconnection SQL codes.
* @see #getDisconnectionSqlCodes()
* @since 2.1
*/
public void setDisconnectionSqlCodes(final Collection disconnectionSqlCodes) {
this.disconnectionSqlCodes = disconnectionSqlCodes;
}
/**
* @param autoCommitOnReturn Whether to auto-commit on return.
* @deprecated Use {@link #setAutoCommitOnReturn(boolean)}.
*/
@Deprecated
public void setEnableAutoCommitOnReturn(final boolean autoCommitOnReturn) {
this.autoCommitOnReturn = autoCommitOnReturn;
}
/**
* @see #isFastFailValidation()
* @param fastFailValidation
* true means connections created by this factory will fast fail validation
* @since 2.1
*/
public void setFastFailValidation(final boolean fastFailValidation) {
this.fastFailValidation = fastFailValidation;
}
/**
* Sets the maximum lifetime in milliseconds of a connection after which the connection will always fail activation,
* passivation and validation. A value of zero or less indicates an infinite lifetime. The default value is -1.
*
* @param maxConnDuration
* The maximum lifetime in milliseconds.
* @since 2.10.0
*/
public void setMaxConn(final Duration maxConnDuration) {
this.maxConnDuration = maxConnDuration;
}
/**
* Sets the maximum lifetime in milliseconds of a connection after which the connection will always fail activation,
* passivation and validation. A value of zero or less indicates an infinite lifetime. The default value is -1.
*
* @param maxConnLifetimeMillis
* The maximum lifetime in milliseconds.
* @deprecated Use {@link #setMaxConn(Duration)}.
*/
@Deprecated
public void setMaxConnLifetimeMillis(final long maxConnLifetimeMillis) {
this.maxConnDuration = Duration.ofMillis(maxConnLifetimeMillis);
}
/**
* Sets the maximum number of open prepared statements.
*
* @param maxOpenPreparedStatements
* The maximum number of open prepared statements.
*/
public void setMaxOpenPreparedStatements(final int maxOpenPreparedStatements) {
this.maxOpenPreparedStatements = maxOpenPreparedStatements;
}
/**
* Deprecated due to typo in method name.
*
* @param maxOpenPreparedStatements
* The maximum number of open prepared statements.
* @deprecated Use {@link #setMaxOpenPreparedStatements(int)}.
*/
@Deprecated // Due to typo in method name.
public void setMaxOpenPrepatedStatements(final int maxOpenPreparedStatements) {
setMaxOpenPreparedStatements(maxOpenPreparedStatements);
}
/**
* Sets the {@link ObjectPool} in which to pool {@link Connection}s.
*
* @param pool
* the {@link ObjectPool} in which to pool those {@link Connection}s
*/
public synchronized void setPool(final ObjectPool pool) {
if (null != this.pool && pool != this.pool) {
Utils.closeQuietly(this.pool);
}
this.pool = pool;
}
public void setPoolStatements(final boolean poolStatements) {
this.poolStatements = poolStatements;
}
public void setRollbackOnReturn(final boolean rollbackOnReturn) {
this.rollbackOnReturn = rollbackOnReturn;
}
/**
* Sets the query I use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. If
* not specified, {@link Connection#isValid(int)} will be used to validate connections.
*
* @param validationQuery
* a query to use to {@link #validateObject validate} {@link Connection}s.
*/
public void setValidationQuery(final String validationQuery) {
this.validationQuery = validationQuery;
}
/**
* Sets the validation query timeout, the amount of time, 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.
*
* @param validationQueryTimeoutDuration new validation query timeout duration.
* @since 2.10.0
*/
public void setValidationQueryTimeout(final Duration validationQueryTimeoutDuration) {
this.validationQueryTimeoutDuration = validationQueryTimeoutDuration;
}
/**
* 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.
*
* @param validationQueryTimeoutSeconds
* new validation query timeout value in seconds
* @deprecated {@link #setValidationQueryTimeout(Duration)}.
*/
@Deprecated
public void setValidationQueryTimeout(final int validationQueryTimeoutSeconds) {
this.validationQueryTimeoutDuration = Duration.ofSeconds(validationQueryTimeoutSeconds);
}
/**
* Validates the given connection if it is open.
*
* @param conn the connection to validate.
* @throws SQLException if the connection is closed or validate fails.
*/
public void validateConnection(final PoolableConnection conn) throws SQLException {
if (conn.isClosed()) {
throw new SQLException("validateConnection: connection closed");
}
conn.validate(validationQuery, validationQueryTimeoutDuration);
}
private void validateLifetime(final PooledObject p) throws LifetimeExceededException {
Utils.validateLifetime(p, maxConnDuration);
}
@Override
public boolean validateObject(final PooledObject p) {
try {
validateLifetime(p);
validateConnection(p.getObject());
return true;
} catch (final Exception e) {
if (log.isDebugEnabled()) {
log.debug(Utils.getMessage("poolableConnectionFactory.validateObject.fail"), e);
}
return false;
}
}
}
PoolableConnectionMXBean.java 0000664 0000000 0000000 00000003741 14473117325 0034033 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.SQLException;
/**
* Defines the attributes and methods that will be exposed via JMX for {@link PoolableConnection} instances.
*
* @since 2.0
*/
public interface PoolableConnectionMXBean {
void clearCachedState();
void clearWarnings() throws SQLException;
void close() throws SQLException;
boolean getAutoCommit() throws SQLException;
boolean getCacheState();
String getCatalog() throws SQLException;
int getHoldability() throws SQLException;
String getSchema() throws SQLException;
String getToString();
int getTransactionIsolation() throws SQLException;
boolean isClosed() throws SQLException;
boolean isReadOnly() throws SQLException;
void reallyClose() throws SQLException;
void setAutoCommit(boolean autoCommit) throws SQLException;
void setCacheState(boolean cacheState);
void setCatalog(String catalog) throws SQLException;
void setHoldability(int holdability) throws SQLException;
void setReadOnly(boolean readOnly) throws SQLException;
void setSchema(String schema) throws SQLException;
void setTransactionIsolation(int level) throws SQLException;
}
PoolablePreparedStatement.java 0000664 0000000 0000000 00000007302 14473117325 0034325 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import org.apache.commons.pool2.KeyedObjectPool;
/**
* A {@link DelegatingPreparedStatement} that cooperates with {@link PoolingConnection} to implement a pool of
* {@link PreparedStatement}s.
*
* My {@link #close} method returns me to my containing pool. (See {@link PoolingConnection}.)
*
*
* @param
* the key type
*
* @see PoolingConnection
* @since 2.0
*/
public class PoolablePreparedStatement extends DelegatingPreparedStatement {
/**
* The {@link KeyedObjectPool} from which I was obtained.
*/
private final KeyedObjectPool> pool;
/**
* My "key" as used by {@link KeyedObjectPool}.
*/
private final K key;
private volatile boolean batchAdded;
/**
* Constructor.
*
* @param stmt
* my underlying {@link PreparedStatement}
* @param key
* my key as used by {@link KeyedObjectPool}
* @param pool
* the {@link KeyedObjectPool} from which I was obtained.
* @param conn
* the {@link java.sql.Connection Connection} from which I was created
*/
public PoolablePreparedStatement(final PreparedStatement stmt, final K key,
final KeyedObjectPool> pool, final DelegatingConnection conn) {
super(conn, stmt);
this.pool = pool;
this.key = key;
// Remove from trace now because this statement will be
// added by the activate method.
removeThisTrace(conn);
}
@Override
public void activate() throws SQLException {
setClosedInternal(false);
AbandonedTrace.add(getConnectionInternal(), this);
super.activate();
}
/**
* Add batch.
*/
@Override
public void addBatch() throws SQLException {
super.addBatch();
batchAdded = true;
}
/**
* Clear Batch.
*/
@Override
public void clearBatch() throws SQLException {
batchAdded = false;
super.clearBatch();
}
/**
* Return me to my pool.
*/
@Override
public void close() throws SQLException {
// calling close twice should have no effect
if (!isClosed()) {
try {
pool.returnObject(key, this);
} catch (final SQLException | RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Cannot close preparedstatement (return to pool failed)", e);
}
}
}
@Override
public void passivate() throws SQLException {
// DBCP-372. clearBatch with throw an exception if called when the
// connection is marked as closed.
if (batchAdded) {
clearBatch();
}
prepareToReturn();
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/PoolingConnection.java 0000664 0000000 0000000 00000054773 14473117325 0032744 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.NoSuchElementException;
import java.util.Objects;
import org.apache.commons.pool2.KeyedObjectPool;
import org.apache.commons.pool2.KeyedPooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
/**
* A {@link DelegatingConnection} that pools {@link PreparedStatement}s.
*
* The {@link #prepareStatement} and {@link #prepareCall} methods, rather than creating a new PreparedStatement each
* time, may actually pull the statement from a pool of unused statements. The {@link PreparedStatement#close} method of
* the returned statement doesn't actually close the statement, but rather returns it to the pool. (See
* {@link PoolablePreparedStatement}, {@link PoolableCallableStatement}.)
*
*
* @see PoolablePreparedStatement
* @since 2.0
*/
public class PoolingConnection extends DelegatingConnection
implements KeyedPooledObjectFactory {
/**
* Statement types.
*
* @since 2.0 protected enum.
* @since 2.4.0 public enum.
*/
public enum StatementType {
/**
* Callable statement.
*/
CALLABLE_STATEMENT,
/**
* Prepared statement.
*/
PREPARED_STATEMENT
}
/** Pool of {@link PreparedStatement}s. and {@link CallableStatement}s */
private KeyedObjectPool pStmtPool;
private boolean clearStatementPoolOnReturn;
/**
* Constructor.
*
* @param connection
* the underlying {@link Connection}.
*/
public PoolingConnection(final Connection connection) {
super(connection);
}
/**
* {@link KeyedPooledObjectFactory} method for activating pooled statements.
*
* @param key
* ignored
* @param pooledObject
* wrapped pooled statement to be activated
*/
@Override
public void activateObject(final PStmtKey key, final PooledObject pooledObject)
throws SQLException {
pooledObject.getObject().activate();
}
/**
* Closes and frees all {@link PreparedStatement}s or {@link CallableStatement}s from the pool, and close the
* underlying connection.
*/
@Override
public synchronized void close() throws SQLException {
try {
if (null != pStmtPool) {
final KeyedObjectPool oldPool = pStmtPool;
pStmtPool = null;
try {
oldPool.close();
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Cannot close connection", e);
}
}
} finally {
try {
getDelegateInternal().close();
} finally {
setClosedInternal(true);
}
}
}
/**
* Notification from {@link PoolableConnection} that we returned to the pool.
*
* @throws SQLException when {@code clearStatementPoolOnReturn} is true and the statement pool could not be
* cleared
* @since 2.8.0
*/
public void connectionReturnedToPool() throws SQLException {
if (pStmtPool != null && clearStatementPoolOnReturn) {
try {
pStmtPool.clear();
} catch (final Exception e) {
throw new SQLException("Error clearing statement pool", e);
}
}
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull());
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param autoGeneratedKeys
* A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final int autoGeneratedKeys) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), autoGeneratedKeys);
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency);
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
* @param resultSetHoldability
* result set holdability
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency,
resultSetHoldability);
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
* @param resultSetHoldability
* result set holdability
* @param statementType
* statement type
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability, final StatementType statementType) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency,
resultSetHoldability, statementType);
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
* @param statementType
* statement type
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency,
final StatementType statementType) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency, statementType);
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param columnIndexes
* An array of column indexes indicating the columns that should be returned from the inserted row or
* rows.
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final int[] columnIndexes) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), columnIndexes);
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param statementType
* statement type
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final StatementType statementType) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), statementType, null);
}
/**
* Creates a PStmtKey for the given arguments.
*
* @param sql
* the SQL string used to define the statement
* @param columnNames
* column names
*
* @return the PStmtKey created for the given arguments.
*/
protected PStmtKey createKey(final String sql, final String[] columnNames) {
return new PStmtKey(normalizeSQL(sql), getCatalogOrNull(), getSchemaOrNull(), columnNames);
}
/**
* {@link KeyedPooledObjectFactory} method for destroying PoolablePreparedStatements and PoolableCallableStatements.
* Closes the underlying statement.
*
* @param key
* ignored
* @param pooledObject
* the wrapped pooled statement to be destroyed.
*/
@Override
public void destroyObject(final PStmtKey key, final PooledObject pooledObject)
throws SQLException {
pooledObject.getObject().getInnermostDelegate().close();
}
private String getCatalogOrNull() {
try {
return getCatalog();
} catch (final SQLException ignored) {
return null;
}
}
private String getSchemaOrNull() {
try {
return getSchema();
} catch (final SQLException ignored) {
return null;
}
}
/**
* Gets the prepared statement pool.
*
* @return statement pool
* @since 2.8.0
*/
public KeyedObjectPool getStatementPool() {
return pStmtPool;
}
/**
* {@link KeyedPooledObjectFactory} method for creating {@link PoolablePreparedStatement}s or
* {@link PoolableCallableStatement}s. The {@code stmtType} field in the key determines whether a
* PoolablePreparedStatement or PoolableCallableStatement is created.
*
* @param key
* the key for the {@link PreparedStatement} to be created
* @see #createKey(String, int, int, StatementType)
*/
@SuppressWarnings("resource")
@Override
public PooledObject makeObject(final PStmtKey key) throws SQLException {
if (null == key) {
throw new IllegalArgumentException("Prepared statement key is null or invalid.");
}
if (key.getStmtType() == StatementType.PREPARED_STATEMENT) {
final PreparedStatement statement = (PreparedStatement) key.createStatement(getDelegate());
@SuppressWarnings({"rawtypes", "unchecked" }) // Unable to find way to avoid this
final PoolablePreparedStatement pps = new PoolablePreparedStatement(statement, key, pStmtPool, this);
return new DefaultPooledObject<>(pps);
}
final CallableStatement statement = (CallableStatement) key.createStatement(getDelegate());
final PoolableCallableStatement pcs = new PoolableCallableStatement(statement, key, pStmtPool, this);
return new DefaultPooledObject<>(pcs);
}
/**
* Normalizes the given SQL statement, producing a canonical form that is semantically equivalent to the original.
*
* @param sql The statement to be normalized.
*
* @return The canonical form of the supplied SQL statement.
*/
protected String normalizeSQL(final String sql) {
return sql.trim();
}
/**
* {@link KeyedPooledObjectFactory} method for passivating {@link PreparedStatement}s or {@link CallableStatement}s.
* Invokes {@link PreparedStatement#clearParameters}.
*
* @param key
* ignored
* @param pooledObject
* a wrapped {@link PreparedStatement}
*/
@Override
public void passivateObject(final PStmtKey key, final PooledObject pooledObject)
throws SQLException {
@SuppressWarnings("resource")
final DelegatingPreparedStatement dps = pooledObject.getObject();
dps.clearParameters();
dps.passivate();
}
/**
* Creates or obtains a {@link CallableStatement} from the pool.
*
* @param key
* a {@link PStmtKey} for the given arguments
* @return a {@link PoolableCallableStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
private CallableStatement prepareCall(final PStmtKey key) throws SQLException {
return (CallableStatement) prepareStatement(key);
}
/**
* Creates or obtains a {@link CallableStatement} from the pool.
*
* @param sql
* the SQL string used to define the CallableStatement
* @return a {@link PoolableCallableStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public CallableStatement prepareCall(final String sql) throws SQLException {
return prepareCall(createKey(sql, StatementType.CALLABLE_STATEMENT));
}
/**
* Creates or obtains a {@link CallableStatement} from the pool.
*
* @param sql
* the SQL string used to define the CallableStatement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
* @return a {@link PoolableCallableStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
return prepareCall(createKey(sql, resultSetType, resultSetConcurrency, StatementType.CALLABLE_STATEMENT));
}
/**
* Creates or obtains a {@link CallableStatement} from the pool.
*
* @param sql
* the SQL string used to define the CallableStatement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
* @param resultSetHoldability
* result set holdability
* @return a {@link PoolableCallableStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
return prepareCall(createKey(sql, resultSetType, resultSetConcurrency,
resultSetHoldability, StatementType.CALLABLE_STATEMENT));
}
/**
* Creates or obtains a {@link PreparedStatement} from the pool.
*
* @param key
* a {@link PStmtKey} for the given arguments
* @return a {@link PoolablePreparedStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
private PreparedStatement prepareStatement(final PStmtKey key) throws SQLException {
if (null == pStmtPool) {
throw new SQLException("Statement pool is null - closed or invalid PoolingConnection.");
}
try {
return pStmtPool.borrowObject(key);
} catch (final NoSuchElementException e) {
throw new SQLException("MaxOpenPreparedStatements limit reached", e);
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
/**
* Creates or obtains a {@link PreparedStatement} from the pool.
*
* @param sql
* the SQL string used to define the PreparedStatement
* @return a {@link PoolablePreparedStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public PreparedStatement prepareStatement(final String sql) throws SQLException {
return prepareStatement(createKey(sql));
}
/*
* Creates or obtains a {@link PreparedStatement} from the pool.
*
* @param sql
* the SQL string used to define the PreparedStatement
* @param autoGeneratedKeys
* A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
* @return a {@link PoolablePreparedStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
return prepareStatement(createKey(sql, autoGeneratedKeys));
}
/**
* Creates or obtains a {@link PreparedStatement} from the pool.
*
* @param sql
* the SQL string used to define the PreparedStatement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
* @return a {@link PoolablePreparedStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
return prepareStatement(createKey(sql, resultSetType, resultSetConcurrency));
}
/**
* Creates or obtains a {@link PreparedStatement} from the pool.
*
* @param sql
* the SQL string used to define the PreparedStatement
* @param resultSetType
* result set type
* @param resultSetConcurrency
* result set concurrency
* @param resultSetHoldability
* result set holdability
* @return a {@link PoolablePreparedStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
return prepareStatement(createKey(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
}
/**
* Creates or obtains a {@link PreparedStatement} from the pool.
*
* @param sql
* the SQL string used to define the PreparedStatement
* @param columnIndexes
* An array of column indexes indicating the columns that should be returned from the inserted row or
* rows.
* @return a {@link PoolablePreparedStatement}
* @throws SQLException
* Wraps an underlying exception.
*
*/
@Override
public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
return prepareStatement(createKey(sql, columnIndexes));
}
/**
* Creates or obtains a {@link PreparedStatement} from the pool.
*
* @param sql
* the SQL string used to define the PreparedStatement
* @param columnNames
* column names
* @return a {@link PoolablePreparedStatement}
* @throws SQLException
* Wraps an underlying exception.
*/
@Override
public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
return prepareStatement(createKey(sql, columnNames));
}
/**
* Sets whether the pool of statements should be cleared when the connection is returned to its pool.
* Default is false.
*
* @param clearStatementPoolOnReturn clear or not
* @since 2.8.0
*/
public void setClearStatementPoolOnReturn(final boolean clearStatementPoolOnReturn) {
this.clearStatementPoolOnReturn = clearStatementPoolOnReturn;
}
/**
* Sets the prepared statement pool.
*
* @param pool
* the prepared statement pool.
*/
public void setStatementPool(final KeyedObjectPool pool) {
pStmtPool = pool;
}
@Override
public synchronized String toString() {
return "PoolingConnection: " + Objects.toString(pStmtPool);
}
/**
* {@link KeyedPooledObjectFactory} method for validating pooled statements. Currently, always returns true.
*
* @param key
* ignored
* @param pooledObject
* ignored
* @return {@code true}
*/
@Override
public boolean validateObject(final PStmtKey key, final PooledObject pooledObject) {
return true;
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/PoolingDataSource.java 0000664 0000000 0000000 00000020341 14473117325 0032657 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.logging.Logger;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPool;
/**
* A simple {@link DataSource} implementation that obtains {@link Connection}s from the specified {@link ObjectPool}.
*
* @param
* The connection type
*
* @since 2.0
*/
public class PoolingDataSource implements DataSource, AutoCloseable {
/**
* PoolGuardConnectionWrapper is a Connection wrapper that makes sure a closed connection cannot be used anymore.
*
* @since 2.0
*/
private class PoolGuardConnectionWrapper extends DelegatingConnection {
PoolGuardConnectionWrapper(final D delegate) {
super(delegate);
}
@Override
public void close() throws SQLException {
if (getDelegateInternal() != null) {
super.close();
super.setDelegate(null);
}
}
/**
* @see org.apache.commons.dbcp2.DelegatingConnection#getDelegate()
*/
@Override
public D getDelegate() {
return isAccessToUnderlyingConnectionAllowed() ? super.getDelegate() : null;
}
/**
* @see org.apache.commons.dbcp2.DelegatingConnection#getInnermostDelegate()
*/
@Override
public Connection getInnermostDelegate() {
return isAccessToUnderlyingConnectionAllowed() ? super.getInnermostDelegate() : null;
}
@Override
public boolean isClosed() throws SQLException {
return getDelegateInternal() == null || super.isClosed();
}
}
private static final Log log = LogFactory.getLog(PoolingDataSource.class);
/** Controls access to the underlying connection */
private boolean accessToUnderlyingConnectionAllowed;
/** My log writer. */
private PrintWriter logWriter;
private final ObjectPool pool;
/**
* Constructs a new instance backed by the given connection pool.
*
* @param pool
* the given connection pool.
*/
public PoolingDataSource(final ObjectPool pool) {
Objects.requireNonNull(pool, "Pool must not be null.");
this.pool = pool;
// Verify that pool's factory refers back to it. If not, log a warning and try to fix.
if (this.pool instanceof GenericObjectPool) {
final PoolableConnectionFactory pcf = (PoolableConnectionFactory) ((GenericObjectPool) this.pool)
.getFactory();
Objects.requireNonNull(pcf, "PoolableConnectionFactory must not be null.");
if (pcf.getPool() != this.pool) {
log.warn(Utils.getMessage("poolingDataSource.factoryConfig"));
@SuppressWarnings("unchecked") // PCF must have a pool of PCs
final ObjectPool p = (ObjectPool) this.pool;
pcf.setPool(p);
}
}
}
/**
* Closes and free all {@link Connection}s from the pool.
*
* @since 2.1
*/
@Override
public void close() throws SQLException {
try {
pool.close();
} catch (final Exception e) {
throw new SQLException(Utils.getMessage("pool.close.fail"), e);
}
}
/**
* Returns a {@link java.sql.Connection} from my pool, according to the contract specified by
* {@link ObjectPool#borrowObject}.
*/
@Override
public Connection getConnection() throws SQLException {
try {
final C conn = pool.borrowObject();
if (conn == null) {
return null;
}
return new PoolGuardConnectionWrapper<>(conn);
} catch (final NoSuchElementException e) {
throw new SQLException("Cannot get a connection, pool error " + e.getMessage(), e);
} catch (final SQLException | RuntimeException e) {
throw e;
} catch (final InterruptedException e) {
// Reset the interrupt status so it is visible to callers
Thread.currentThread().interrupt();
throw new SQLException("Cannot get a connection, general error", e);
} catch (final Exception e) {
throw new SQLException("Cannot get a connection, general error", e);
}
}
/**
* Throws {@link UnsupportedOperationException}
*
* @throws UnsupportedOperationException
* always thrown
*/
@Override
public Connection getConnection(final String uname, final String passwd) throws SQLException {
throw new UnsupportedOperationException();
}
// --- DataSource methods -----------------------------------------
/**
* Throws {@link UnsupportedOperationException}.
*
* @throws UnsupportedOperationException
* As this implementation does not support this feature.
*/
@Override
public int getLoginTimeout() {
throw new UnsupportedOperationException("Login timeout is not supported.");
}
/**
* Returns my log writer.
*
* @return my log writer
* @see DataSource#getLogWriter
*/
@Override
public PrintWriter getLogWriter() {
return logWriter;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new SQLFeatureNotSupportedException();
}
protected ObjectPool getPool() {
return pool;
}
/**
* Returns the value of the accessToUnderlyingConnectionAllowed property.
*
* @return true if access to the underlying {@link Connection} is allowed, false otherwise.
*/
public boolean isAccessToUnderlyingConnectionAllowed() {
return this.accessToUnderlyingConnectionAllowed;
}
@Override
public boolean isWrapperFor(final Class iface) throws SQLException {
return iface != null && iface.isInstance(this);
}
/**
* Sets the value of the accessToUnderlyingConnectionAllowed property. It controls if the PoolGuard allows access to
* the underlying connection. (Default: false)
*
* @param allow
* Access to the underlying connection is granted when true.
*/
public void setAccessToUnderlyingConnectionAllowed(final boolean allow) {
this.accessToUnderlyingConnectionAllowed = allow;
}
/**
* Throws {@link UnsupportedOperationException}.
*
* @throws UnsupportedOperationException
* As this implementation does not support this feature.
*/
@Override
public void setLoginTimeout(final int seconds) {
throw new UnsupportedOperationException("Login timeout is not supported.");
}
/**
* Sets my log writer.
*
* @see DataSource#setLogWriter
*/
@Override
public void setLogWriter(final PrintWriter out) {
logWriter = out;
}
@Override
public T unwrap(final Class iface) throws SQLException {
if (isWrapperFor(iface)) {
return iface.cast(this);
}
throw new SQLException(this + " is not a wrapper for " + iface);
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/PoolingDriver.java 0000664 0000000 0000000 00000021065 14473117325 0032064 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.HashMap;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.logging.Logger;
import org.apache.commons.pool2.ObjectPool;
/**
* A {@link Driver} implementation that obtains {@link Connection}s from a registered {@link ObjectPool}.
*
* @since 2.0
*/
public class PoolingDriver implements Driver {
/**
* PoolGuardConnectionWrapper is a Connection wrapper that makes sure a closed connection cannot be used anymore.
*
* @since 2.0
*/
private class PoolGuardConnectionWrapper extends DelegatingConnection {
private final ObjectPool pool;
PoolGuardConnectionWrapper(final ObjectPool pool, final Connection delegate) {
super(delegate);
this.pool = pool;
}
/**
* @see org.apache.commons.dbcp2.DelegatingConnection#getDelegate()
*/
@Override
public Connection getDelegate() {
if (isAccessToUnderlyingConnectionAllowed()) {
return super.getDelegate();
}
return null;
}
/**
* @see org.apache.commons.dbcp2.DelegatingConnection#getInnermostDelegate()
*/
@Override
public Connection getInnermostDelegate() {
if (isAccessToUnderlyingConnectionAllowed()) {
return super.getInnermostDelegate();
}
return null;
}
}
private static final DriverPropertyInfo[] EMPTY_DRIVER_PROPERTY_INFO_ARRAY = {};
/* Register myself with the {@link DriverManager}. */
static {
try {
DriverManager.registerDriver(new PoolingDriver());
} catch (final Exception ignored) {
// Ignored
}
}
/** The map of registered pools. */
protected static final HashMap> pools = new HashMap<>();
/** My URL prefix */
public static final String URL_PREFIX = "jdbc:apache:commons:dbcp:";
protected static final int URL_PREFIX_LEN = URL_PREFIX.length();
// version numbers
protected static final int MAJOR_VERSION = 1;
protected static final int MINOR_VERSION = 0;
/** Controls access to the underlying connection */
private final boolean accessToUnderlyingConnectionAllowed;
/**
* Constructs a new driver with {@code accessToUnderlyingConnectionAllowed} enabled.
*/
public PoolingDriver() {
this(true);
}
/**
* For unit testing purposes.
*
* @param accessToUnderlyingConnectionAllowed
* Do {@link DelegatingConnection}s created by this driver permit access to the delegate?
*/
protected PoolingDriver(final boolean accessToUnderlyingConnectionAllowed) {
this.accessToUnderlyingConnectionAllowed = accessToUnderlyingConnectionAllowed;
}
@Override
public boolean acceptsURL(final String url) throws SQLException {
return url != null && url.startsWith(URL_PREFIX);
}
/**
* Closes a named pool.
*
* @param name
* The pool name.
* @throws SQLException
* Thrown when a problem is caught closing the pool.
*/
public synchronized void closePool(final String name) throws SQLException {
@SuppressWarnings("resource")
final ObjectPool pool = pools.get(name);
if (pool != null) {
pools.remove(name);
try {
pool.close();
} catch (final Exception e) {
throw new SQLException("Error closing pool " + name, e);
}
}
}
@Override
public Connection connect(final String url, final Properties info) throws SQLException {
if (acceptsURL(url)) {
final ObjectPool pool = getConnectionPool(url.substring(URL_PREFIX_LEN));
try {
final Connection conn = pool.borrowObject();
if (conn == null) {
return null;
}
return new PoolGuardConnectionWrapper(pool, conn);
} catch (final NoSuchElementException e) {
throw new SQLException("Cannot get a connection, pool error: " + e.getMessage(), e);
} catch (final SQLException | RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Cannot get a connection, general error: " + e.getMessage(), e);
}
}
return null;
}
/**
* Gets the connection pool for the given name.
*
* @param name
* The pool name
* @return The pool
* @throws SQLException
* Thrown when the named pool is not registered.
*/
public synchronized ObjectPool getConnectionPool(final String name) throws SQLException {
final ObjectPool pool = pools.get(name);
if (null == pool) {
throw new SQLException("Pool not registered: " + name);
}
return pool;
}
@Override
public int getMajorVersion() {
return MAJOR_VERSION;
}
@Override
public int getMinorVersion() {
return MINOR_VERSION;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new SQLFeatureNotSupportedException();
}
/**
* Gets the pool names.
*
* @return the pool names.
*/
public synchronized String[] getPoolNames() {
return pools.keySet().toArray(Utils.EMPTY_STRING_ARRAY);
}
@Override
public DriverPropertyInfo[] getPropertyInfo(final String url, final Properties info) {
return EMPTY_DRIVER_PROPERTY_INFO_ARRAY;
}
/**
* Invalidates the given connection.
*
* @param conn
* connection to invalidate
* @throws SQLException
* if the connection is not a {@code PoolGuardConnectionWrapper} or an error occurs invalidating
* the connection
*/
public void invalidateConnection(final Connection conn) throws SQLException {
if (!(conn instanceof PoolGuardConnectionWrapper)) {
throw new SQLException("Invalid connection class");
}
final PoolGuardConnectionWrapper pgconn = (PoolGuardConnectionWrapper) conn;
@SuppressWarnings("unchecked")
final ObjectPool pool = (ObjectPool) pgconn.pool;
try {
pool.invalidateObject(pgconn.getDelegateInternal());
} catch (final Exception ignored) {
// Ignored.
}
}
/**
* Returns the value of the accessToUnderlyingConnectionAllowed property.
*
* @return true if access to the underlying is allowed, false otherwise.
*/
protected boolean isAccessToUnderlyingConnectionAllowed() {
return accessToUnderlyingConnectionAllowed;
}
@Override
public boolean jdbcCompliant() {
return true;
}
/**
* Registers a named pool.
*
* @param name
* The pool name.
* @param pool
* The pool.
*/
public synchronized void registerPool(final String name, final ObjectPool pool) {
pools.put(name, pool);
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/SQLExceptionList.java 0000664 0000000 0000000 00000003625 14473117325 0032455 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.SQLException;
import java.util.List;
/**
* An SQLException based on a list of Throwable causes.
*
* The first exception in the list is used as this exception's cause and is accessible with the usual
* {@link #getCause()} while the complete list is accessible with {@link #getCauseList()}.
*
*
* @since 2.7.0
*/
public class SQLExceptionList extends SQLException {
private static final long serialVersionUID = 1L;
private final List causeList;
/**
* Creates a new exception caused by a list of exceptions.
*
* @param causeList a list of cause exceptions.
*/
public SQLExceptionList(final List causeList) {
super(String.format("%,d exceptions: %s", causeList == null ? 0 : causeList.size(), causeList),
causeList == null ? null : causeList.get(0));
this.causeList = causeList;
}
/**
* Gets the cause list.
*
* @return The list of causes.
*/
public List getCauseList() {
return causeList;
}
}
SwallowedExceptionLogger.java 0000664 0000000 0000000 00000004147 14473117325 0034204 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import org.apache.commons.logging.Log;
import org.apache.commons.pool2.SwallowedExceptionListener;
/**
* Class for logging swallowed exceptions.
*
* @since 2.0
*/
public class SwallowedExceptionLogger implements SwallowedExceptionListener {
private final Log log;
private final boolean logExpiredConnections;
/**
* Create a SwallowedExceptionLogger with the given logger. By default, expired connection logging is turned on.
*
* @param log
* logger
*/
public SwallowedExceptionLogger(final Log log) {
this(log, true);
}
/**
* Create a SwallowedExceptionLogger with the given logger and expired connection logging property.
*
* @param log
* logger
* @param logExpiredConnections
* false suppresses logging of expired connection events
*/
public SwallowedExceptionLogger(final Log log, final boolean logExpiredConnections) {
this.log = log;
this.logExpiredConnections = logExpiredConnections;
}
@Override
public void onSwallowException(final Exception e) {
if (logExpiredConnections || !(e instanceof LifetimeExceededException)) {
log.warn(Utils.getMessage("swallowedExceptionLogger.onSwallowedException"), e);
}
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/Utils.java 0000664 0000000 0000000 00000020747 14473117325 0030407 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.text.MessageFormat;
import java.time.Duration;
import java.time.Instant;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.function.Consumer;
import org.apache.commons.pool2.PooledObject;
/**
* Utility methods.
*
* @since 2.0
*/
public final class Utils {
private static final ResourceBundle messages = ResourceBundle
.getBundle(Utils.class.getPackage().getName() + ".LocalStrings");
/**
* Whether the security manager is enabled.
*
* @deprecated No replacement.
*/
@Deprecated
public static final boolean IS_SECURITY_ENABLED = isSecurityEnabled();
/** Any SQL_STATE starting with this value is considered a fatal disconnect */
public static final String DISCONNECTION_SQL_CODE_PREFIX = "08";
/**
* SQL codes of fatal connection errors.
*
* - 57P01 (Admin shutdown)
* - 57P02 (Crash shutdown)
* - 57P03 (Cannot connect now)
* - 01002 (SQL92 disconnect error)
* - JZ0C0 (Sybase disconnect error)
* - JZ0C1 (Sybase disconnect error)
*
* @deprecated Use {@link #getDisconnectionSqlCodes()}.
*/
@Deprecated
public static final Set DISCONNECTION_SQL_CODES;
static final ResultSet[] EMPTY_RESULT_SET_ARRAY = {};
static final String[] EMPTY_STRING_ARRAY = {};
static {
DISCONNECTION_SQL_CODES = new HashSet<>();
DISCONNECTION_SQL_CODES.add("57P01"); // Admin shutdown
DISCONNECTION_SQL_CODES.add("57P02"); // Crash shutdown
DISCONNECTION_SQL_CODES.add("57P03"); // Cannot connect now
DISCONNECTION_SQL_CODES.add("01002"); // SQL92 disconnect error
DISCONNECTION_SQL_CODES.add("JZ0C0"); // Sybase disconnect error
DISCONNECTION_SQL_CODES.add("JZ0C1"); // Sybase disconnect error
}
/**
* Clones the given char[] if not null.
*
* @param value may be null.
* @return a cloned char[] or null.
*/
public static char[] clone(final char[] value) {
return value == null ? null : value.clone();
}
/**
* Clones the given {@link Properties} without the standard "user" or "password" entries.
*
* @param properties may be null
* @return a clone of the input without the standard "user" or "password" entries.
* @since 2.8.0
*/
public static Properties cloneWithoutCredentials(final Properties properties) {
if (properties != null) {
final Properties temp = (Properties) properties.clone();
temp.remove(Constants.KEY_USER);
temp.remove(Constants.KEY_PASSWORD);
return temp;
}
return properties;
}
/**
* Closes the given {@link AutoCloseable} and if an exception is caught, then calls {@code exceptionHandler}.
*
* @param autoCloseable The resource to close.
* @param exceptionHandler Consumes exception thrown closing this resource.
* @since 2.10.0
*/
public static void close(AutoCloseable autoCloseable, final Consumer exceptionHandler) {
if (autoCloseable != null) {
try {
autoCloseable.close();
} catch (final Exception e) {
if (exceptionHandler != null) {
exceptionHandler.accept(e);
}
}
}
}
/**
* Closes the AutoCloseable (which may be null).
*
* @param autoCloseable an AutoCloseable, may be {@code null}
* @since 2.6.0
*/
public static void closeQuietly(final AutoCloseable autoCloseable) {
close(autoCloseable, null);
}
/**
* Closes the Connection (which may be null).
*
* @param connection a Connection, may be {@code null}
* @deprecated Use {@link #closeQuietly(AutoCloseable)}.
*/
@Deprecated
public static void closeQuietly(final Connection connection) {
closeQuietly((AutoCloseable) connection);
}
/**
* Closes the ResultSet (which may be null).
*
* @param resultSet a ResultSet, may be {@code null}
* @deprecated Use {@link #closeQuietly(AutoCloseable)}.
*/
@Deprecated
public static void closeQuietly(final ResultSet resultSet) {
closeQuietly((AutoCloseable) resultSet);
}
/**
* Closes the Statement (which may be null).
*
* @param statement a Statement, may be {@code null}.
* @deprecated Use {@link #closeQuietly(AutoCloseable)}.
*/
@Deprecated
public static void closeQuietly(final Statement statement) {
closeQuietly((AutoCloseable) statement);
}
/**
* Gets a copy of SQL codes of fatal connection errors.
*
* - 57P01 (Admin shutdown)
* - 57P02 (Crash shutdown)
* - 57P03 (Cannot connect now)
* - 01002 (SQL92 disconnect error)
* - JZ0C0 (Sybase disconnect error)
* - JZ0C1 (Sybase disconnect error)
*
* @return SQL codes of fatal connection errors.
* @since 2.10.0
*/
public static Set getDisconnectionSqlCodes() {
return new HashSet<>(DISCONNECTION_SQL_CODES);
}
/**
* Gets the correct i18n message for the given key.
*
* @param key The key to look up an i18n message.
* @return The i18n message.
*/
public static String getMessage(final String key) {
return getMessage(key, (Object[]) null);
}
/**
* Gets the correct i18n message for the given key with placeholders replaced by the supplied arguments.
*
* @param key A message key.
* @param args The message arguments.
* @return An i18n message.
*/
public static String getMessage(final String key, final Object... args) {
final String msg = messages.getString(key);
if (args == null || args.length == 0) {
return msg;
}
final MessageFormat mf = new MessageFormat(msg);
return mf.format(args, new StringBuffer(), null).toString();
}
static boolean isEmpty(final Collection collection) {
return collection == null || collection.isEmpty();
}
static boolean isSecurityEnabled() {
return System.getSecurityManager() != null;
}
/**
* Converts the given String to a char[].
*
* @param value may be null.
* @return a char[] or null.
*/
public static char[] toCharArray(final String value) {
return value != null ? value.toCharArray() : null;
}
/**
* Converts the given char[] to a String.
*
* @param value may be null.
* @return a String or null.
*/
public static String toString(final char[] value) {
return value == null ? null : String.valueOf(value);
}
public static void validateLifetime(final PooledObject p, final Duration maxDuration) throws LifetimeExceededException {
if (maxDuration.compareTo(Duration.ZERO) > 0) {
final Duration lifetimeDuration = Duration.between(p.getCreateInstant(), Instant.now());
if (lifetimeDuration.compareTo(maxDuration) > 0) {
throw new LifetimeExceededException(Utils.getMessage("connectionFactory.lifetimeExceeded", lifetimeDuration, maxDuration));
}
}
}
private Utils() {
// not instantiable
}
}
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/cpdsadapter/ 0000775 0000000 0000000 00000000000 14473117325 0030724 5 ustar 00root root 0000000 0000000 ConnectionImpl.java 0000664 0000000 0000000 00000031316 14473117325 0034435 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/cpdsadapter /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.cpdsadapter;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import org.apache.commons.dbcp2.DelegatingCallableStatement;
import org.apache.commons.dbcp2.DelegatingConnection;
import org.apache.commons.dbcp2.DelegatingPreparedStatement;
/**
* This class is the {@code Connection} that will be returned from
* {@code PooledConnectionImpl.getConnection()}. Most methods are wrappers around the JDBC 1.x
* {@code Connection}. A few exceptions include preparedStatement and close. In accordance with the JDBC
* specification this Connection cannot be used after closed() is called. Any further usage will result in an
* SQLException.
*
* ConnectionImpl extends DelegatingConnection to enable access to the underlying connection.
*
*
* @since 2.0
*/
final class ConnectionImpl extends DelegatingConnection {
private final boolean accessToUnderlyingConnectionAllowed;
/** The object that instantiated this object */
private final PooledConnectionImpl pooledConnection;
/**
* Creates a {@code ConnectionImpl}.
*
* @param pooledConnection
* The PooledConnection that is calling the ctor.
* @param connection
* The JDBC 1.x Connection to wrap.
* @param accessToUnderlyingConnectionAllowed
* if true, then access is allowed to the underlying connection
*/
ConnectionImpl(final PooledConnectionImpl pooledConnection, final Connection connection,
final boolean accessToUnderlyingConnectionAllowed) {
super(connection);
this.pooledConnection = pooledConnection;
this.accessToUnderlyingConnectionAllowed = accessToUnderlyingConnectionAllowed;
}
/**
* Marks the Connection as closed, and notifies the pool that the pooled connection is available.
*
* In accordance with the JDBC specification this Connection cannot be used after closed() is called. Any further
* usage will result in an SQLException.
*
*
* @throws SQLException
* The database connection couldn't be closed.
*/
@Override
public void close() throws SQLException {
if (!isClosedInternal()) {
try {
passivate();
} finally {
setClosedInternal(true);
pooledConnection.notifyListeners();
}
}
}
/**
* Get the delegated connection, if allowed.
*
* @return the internal connection, or null if access is not allowed.
* @see #isAccessToUnderlyingConnectionAllowed()
*/
@Override
public Connection getDelegate() {
if (isAccessToUnderlyingConnectionAllowed()) {
return getDelegateInternal();
}
return null;
}
/**
* Get the innermost connection, if allowed.
*
* @return the innermost internal connection, or null if access is not allowed.
* @see #isAccessToUnderlyingConnectionAllowed()
*/
@Override
public Connection getInnermostDelegate() {
if (isAccessToUnderlyingConnectionAllowed()) {
return super.getInnermostDelegateInternal();
}
return null;
}
/**
* If false, getDelegate() and getInnermostDelegate() will return null.
*
* @return true if access is allowed to the underlying connection
* @see ConnectionImpl
*/
public boolean isAccessToUnderlyingConnectionAllowed() {
return accessToUnderlyingConnectionAllowed;
}
/**
* If pooling of {@code CallableStatement}s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
* be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
* @param sql
* an SQL statement that may contain one or more '?' parameter placeholders. Typically, this statement is
* specified using JDBC call escape syntax.
* @return a default {@code CallableStatement} object containing the pre-compiled SQL statement.
* @throws SQLException
* Thrown if a database access error occurs or this method is called on a closed connection.
* @since 2.4.0
*/
@Override
public CallableStatement prepareCall(final String sql) throws SQLException {
checkOpen();
try {
return new DelegatingCallableStatement(this, pooledConnection.prepareCall(sql));
} catch (final SQLException e) {
handleException(e); // Does not return
return null;
}
}
/**
* If pooling of {@code CallableStatement}s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
* be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
* @param sql
* a {@code String} object that is the SQL statement to be sent to the database; may contain on or
* more '?' parameters.
* @param resultSetType
* a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* a concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @return a {@code CallableStatement} object containing the pre-compiled SQL statement that will produce
* {@code ResultSet} objects with the given type and concurrency.
* @throws SQLException
* Thrown if a database access error occurs, this method is called on a closed connection or the given
* parameters are not {@code ResultSet} constants indicating type and concurrency.
* @since 2.4.0
*/
@Override
public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
checkOpen();
try {
return new DelegatingCallableStatement(this,
pooledConnection.prepareCall(sql, resultSetType, resultSetConcurrency));
} catch (final SQLException e) {
handleException(e); // Does not return
return null;
}
}
/**
* If pooling of {@code CallableStatement}s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
* be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
* @param sql
* a {@code String} object that is the SQL statement to be sent to the database; may contain on or
* more '?' parameters.
* @param resultSetType
* one of the following {@code ResultSet} constants: {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* one of the following {@code ResultSet} constants: {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param resultSetHoldability
* one of the following {@code ResultSet} constants: {@code ResultSet.HOLD_CURSORS_OVER_COMMIT}
* or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @return a new {@code CallableStatement} object, containing the pre-compiled SQL statement, that will
* generate {@code ResultSet} objects with the given type, concurrency, and holdability.
* @throws SQLException
* Thrown if a database access error occurs, this method is called on a closed connection or the given
* parameters are not {@code ResultSet} constants indicating type, concurrency, and holdability.
* @since 2.4.0
*/
@Override
public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
checkOpen();
try {
return new DelegatingCallableStatement(this,
pooledConnection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
} catch (final SQLException e) {
handleException(e); // Does not return
return null;
}
}
/**
* If pooling of {@code PreparedStatement}s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
* be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
* @param sql
* SQL statement to be prepared
* @return the prepared statement
* @throws SQLException
* if this connection is closed or an error occurs in the wrapped connection.
*/
@Override
public PreparedStatement prepareStatement(final String sql) throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql));
} catch (final SQLException e) {
handleException(e); // Does not return
return null;
}
}
@Override
public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql, autoGeneratedKeys));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
/**
* If pooling of {@code PreparedStatement}s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
* be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
* @throws SQLException
* if this connection is closed or an error occurs in the wrapped connection.
*/
@Override
public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this,
pooledConnection.prepareStatement(sql, resultSetType, resultSetConcurrency));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
//
// Methods for accessing the delegate connection
//
@Override
public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this,
pooledConnection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql, columnIndexes));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql, columnNames));
} catch (final SQLException e) {
handleException(e);
return null;
}
}
}
DriverAdapterCPDS.java 0000664 0000000 0000000 00000100702 14473117325 0034716 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/cpdsadapter /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.cpdsadapter;
import java.io.PrintWriter;
import java.io.Serializable;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.time.Duration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.NamingException;
import javax.naming.RefAddr;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.StringRefAddr;
import javax.naming.spi.ObjectFactory;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import org.apache.commons.dbcp2.Constants;
import org.apache.commons.dbcp2.DelegatingPreparedStatement;
import org.apache.commons.dbcp2.PStmtKey;
import org.apache.commons.dbcp2.Utils;
import org.apache.commons.pool2.KeyedObjectPool;
import org.apache.commons.pool2.impl.BaseObjectPoolConfig;
import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
/**
*
* An adapter for JDBC drivers that do not include an implementation of {@link javax.sql.ConnectionPoolDataSource}, but
* still include a {@link java.sql.DriverManager} implementation. {@code ConnectionPoolDataSource}s are not used
* within general applications. They are used by {@code DataSource} implementations that pool
* {@code Connection}s, such as {@link org.apache.commons.dbcp2.datasources.SharedPoolDataSource}. A J2EE container
* will normally provide some method of initializing the {@code ConnectionPoolDataSource} whose attributes are
* presented as bean getters/setters and then deploying it via JNDI. It is then available as a source of physical
* connections to the database, when the pooling {@code DataSource} needs to create a new physical connection.
*
*
* Although normally used within a JNDI environment, the DriverAdapterCPDS can be instantiated and initialized as any
* bean and then attached directly to a pooling {@code DataSource}. {@code Jdbc2PoolDataSource} can use the
* {@code ConnectionPoolDataSource} with or without the use of JNDI.
*
*
* The DriverAdapterCPDS also provides {@code PreparedStatement} pooling which is not generally available in jdbc2
* {@code ConnectionPoolDataSource} implementation, but is addressed within the jdbc3 specification. The
* {@code PreparedStatement} pool in DriverAdapterCPDS has been in the dbcp package for some time, but it has not
* undergone extensive testing in the configuration used here. It should be considered experimental and can be toggled
* with the poolPreparedStatements attribute.
*
*
* The package documentation contains an example using catalina and JNDI. The
* datasources package documentation shows how to use
* {@code DriverAdapterCPDS} as a source for {@code Jdbc2PoolDataSource} without the use of JNDI.
*
*
* @since 2.0
*/
public class DriverAdapterCPDS implements ConnectionPoolDataSource, Referenceable, Serializable, ObjectFactory {
private static final long serialVersionUID = -4820523787212147844L;
private static final String GET_CONNECTION_CALLED = "A PooledConnection was already requested from this source, "
+ "further initialization is not allowed.";
static {
// Attempt to prevent deadlocks - see DBCP - 272
DriverManager.getDrivers();
}
/** Description */
private String description;
/** Connection string */
private String connectionString;
/** User name */
private String userName;
/** User password */
private char[] userPassword;
/** Driver class name */
private String driver;
/** Login TimeOut in seconds */
private int loginTimeout;
/** Log stream. NOT USED */
private transient PrintWriter logWriter;
// PreparedStatement pool properties
private boolean poolPreparedStatements;
private int maxIdle = 10;
private Duration durationBetweenEvictionRuns = BaseObjectPoolConfig.DEFAULT_TIME_BETWEEN_EVICTION_RUNS;
private int numTestsPerEvictionRun = -1;
private Duration minEvictableIdleDuration = BaseObjectPoolConfig.DEFAULT_MIN_EVICTABLE_IDLE_DURATION;
private int maxPreparedStatements = -1;
/** Whether or not getConnection has been called */
private volatile boolean getConnectionCalled;
/** Connection properties passed to JDBC Driver */
private Properties connectionProperties;
/**
* Controls access to the underlying connection
*/
private boolean accessToUnderlyingConnectionAllowed;
/**
* Default no-argument constructor for Serialization
*/
public DriverAdapterCPDS() {
}
/**
* Throws an IllegalStateException, if a PooledConnection has already been requested.
*/
private void assertInitializationAllowed() throws IllegalStateException {
if (getConnectionCalled) {
throw new IllegalStateException(GET_CONNECTION_CALLED);
}
}
private boolean getBooleanContentString(final RefAddr ra) {
return Boolean.parseBoolean(getStringContent(ra));
}
/**
* Gets the connection properties passed to the JDBC driver.
*
* @return the JDBC connection properties used when creating connections.
*/
public Properties getConnectionProperties() {
return connectionProperties;
}
/**
* Gets the value of description. This property is here for use by the code which will deploy this data source. It
* is not used internally.
*
* @return value of description, may be null.
* @see #setDescription(String)
*/
public String getDescription() {
return description;
}
/**
* Gets the driver class name.
*
* @return value of driver.
*/
public String getDriver() {
return driver;
}
/**
* Gets the duration to sleep between runs of the idle object evictor thread. When non-positive, no
* idle object evictor thread will be run.
*
* @return the value of the evictor thread timer
* @see #setDurationBetweenEvictionRuns(Duration)
* @since 2.9.0
*/
public Duration getDurationBetweenEvictionRuns() {
return durationBetweenEvictionRuns;
}
private int getIntegerStringContent(final RefAddr ra) {
return Integer.parseInt(getStringContent(ra));
}
/**
* Gets the maximum time in seconds that this data source can wait while attempting to connect to a database. NOT
* USED.
*/
@Override
public int getLoginTimeout() {
return loginTimeout;
}
/**
* Gets the log writer for this data source. NOT USED.
*/
@Override
public PrintWriter getLogWriter() {
return logWriter;
}
/**
* Gets the maximum number of statements that can remain idle in the pool, without extra ones being released, or
* negative for no limit.
*
* @return the value of maxIdle
*/
public int getMaxIdle() {
return maxIdle;
}
/**
* Gets the maximum number of prepared statements.
*
* @return maxPrepartedStatements value
*/
public int getMaxPreparedStatements() {
return maxPreparedStatements;
}
/**
* Gets the minimum amount of time a statement may sit idle in the pool before it is eligible for eviction by the
* idle object evictor (if any).
*
* @see #setMinEvictableIdleDuration
* @see #setDurationBetweenEvictionRuns
* @return the minimum amount of time a statement may sit idle in the pool.
* @since 2.9.0
*/
public Duration getMinEvictableIdleDuration() {
return minEvictableIdleDuration;
}
/**
* Gets the minimum amount of time a statement may sit idle in the pool before it is eligible for eviction by the
* idle object evictor (if any).
*
* @see #setMinEvictableIdleTimeMillis
* @see #setTimeBetweenEvictionRunsMillis
* @return the minimum amount of time a statement may sit idle in the pool.
* @deprecated USe {@link #getMinEvictableIdleDuration()}.
*/
@Deprecated
public int getMinEvictableIdleTimeMillis() {
return (int) minEvictableIdleDuration.toMillis();
}
/**
* Gets the number of statements to examine during each run of the idle object evictor thread (if any.)
*
* @see #setNumTestsPerEvictionRun
* @see #setTimeBetweenEvictionRunsMillis
* @return the number of statements to examine during each run of the idle object evictor thread (if any.)
*/
public int getNumTestsPerEvictionRun() {
return numTestsPerEvictionRun;
}
/**
* Implements {@link ObjectFactory} to create an instance of this class
*/
@Override
public Object getObjectInstance(final Object refObj, final Name name, final Context context,
final Hashtable env) throws ClassNotFoundException {
// The spec says to return null if we can't create an instance
// of the reference
DriverAdapterCPDS cpds = null;
if (refObj instanceof Reference) {
final Reference ref = (Reference) refObj;
if (ref.getClassName().equals(getClass().getName())) {
RefAddr ra = ref.get("description");
if (isNotEmpty(ra)) {
setDescription(getStringContent(ra));
}
ra = ref.get("driver");
if (isNotEmpty(ra)) {
setDriver(getStringContent(ra));
}
ra = ref.get("url");
if (isNotEmpty(ra)) {
setUrl(getStringContent(ra));
}
ra = ref.get(Constants.KEY_USER);
if (isNotEmpty(ra)) {
setUser(getStringContent(ra));
}
ra = ref.get(Constants.KEY_PASSWORD);
if (isNotEmpty(ra)) {
setPassword(getStringContent(ra));
}
ra = ref.get("poolPreparedStatements");
if (isNotEmpty(ra)) {
setPoolPreparedStatements(getBooleanContentString(ra));
}
ra = ref.get("maxIdle");
if (isNotEmpty(ra)) {
setMaxIdle(getIntegerStringContent(ra));
}
ra = ref.get("timeBetweenEvictionRunsMillis");
if (isNotEmpty(ra)) {
setTimeBetweenEvictionRunsMillis(getIntegerStringContent(ra));
}
ra = ref.get("numTestsPerEvictionRun");
if (isNotEmpty(ra)) {
setNumTestsPerEvictionRun(getIntegerStringContent(ra));
}
ra = ref.get("minEvictableIdleTimeMillis");
if (isNotEmpty(ra)) {
setMinEvictableIdleTimeMillis(getIntegerStringContent(ra));
}
ra = ref.get("maxPreparedStatements");
if (isNotEmpty(ra)) {
setMaxPreparedStatements(getIntegerStringContent(ra));
}
ra = ref.get("accessToUnderlyingConnectionAllowed");
if (isNotEmpty(ra)) {
setAccessToUnderlyingConnectionAllowed(getBooleanContentString(ra));
}
cpds = this;
}
}
return cpds;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new SQLFeatureNotSupportedException();
}
/**
* Gets the value of password for the default user.
*
* @return value of password.
*/
public String getPassword() {
return Utils.toString(userPassword);
}
/**
* Gets the value of password for the default user.
*
* @return value of password.
* @since 2.4.0
*/
public char[] getPasswordCharArray() {
return Utils.clone(userPassword);
}
/**
* Attempts to establish a database connection using the default user and password.
*/
@Override
public PooledConnection getPooledConnection() throws SQLException {
return getPooledConnection(getUser(), getPassword());
}
/**
* Attempts to establish a database connection.
*
* @param pooledUserName name to be used for the connection
* @param pooledUserPassword password to be used fur the connection
*/
@Override
public PooledConnection getPooledConnection(final String pooledUserName, final String pooledUserPassword)
throws SQLException {
getConnectionCalled = true;
PooledConnectionImpl pooledConnection = null;
// Workaround for buggy WebLogic 5.1 class loader - ignore the exception upon first invocation.
try {
if (connectionProperties != null) {
update(connectionProperties, Constants.KEY_USER, pooledUserName);
update(connectionProperties, Constants.KEY_PASSWORD, pooledUserPassword);
pooledConnection = new PooledConnectionImpl(
DriverManager.getConnection(getUrl(), connectionProperties));
} else {
pooledConnection = new PooledConnectionImpl(
DriverManager.getConnection(getUrl(), pooledUserName, pooledUserPassword));
}
pooledConnection.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed());
} catch (final ClassCircularityError e) {
if (connectionProperties != null) {
pooledConnection = new PooledConnectionImpl(
DriverManager.getConnection(getUrl(), connectionProperties));
} else {
pooledConnection = new PooledConnectionImpl(
DriverManager.getConnection(getUrl(), pooledUserName, pooledUserPassword));
}
pooledConnection.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed());
}
KeyedObjectPool stmtPool = null;
if (isPoolPreparedStatements()) {
final GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig<>();
config.setMaxTotalPerKey(Integer.MAX_VALUE);
config.setBlockWhenExhausted(false);
config.setMaxWait(Duration.ZERO);
config.setMaxIdlePerKey(getMaxIdle());
if (getMaxPreparedStatements() <= 0) {
// Since there is no limit, create a prepared statement pool with an eviction thread;
// evictor settings are the same as the connection pool settings.
config.setTimeBetweenEvictionRuns(getDurationBetweenEvictionRuns());
config.setNumTestsPerEvictionRun(getNumTestsPerEvictionRun());
config.setMinEvictableIdleTime(getMinEvictableIdleDuration());
} else {
// Since there is a limit, create a prepared statement pool without an eviction thread;
// pool has LRU functionality so when the limit is reached, 15% of the pool is cleared.
// see org.apache.commons.pool2.impl.GenericKeyedObjectPool.clearOldest method
config.setMaxTotal(getMaxPreparedStatements());
config.setTimeBetweenEvictionRuns(Duration.ofMillis(-1));
config.setNumTestsPerEvictionRun(0);
config.setMinEvictableIdleTime(Duration.ZERO);
}
stmtPool = new GenericKeyedObjectPool<>(pooledConnection, config);
pooledConnection.setStatementPool(stmtPool);
}
return pooledConnection;
}
/**
* Implements {@link Referenceable}.
*/
@Override
public Reference getReference() throws NamingException {
// this class implements its own factory
final String factory = getClass().getName();
final Reference ref = new Reference(getClass().getName(), factory, null);
ref.add(new StringRefAddr("description", getDescription()));
ref.add(new StringRefAddr("driver", getDriver()));
ref.add(new StringRefAddr("loginTimeout", String.valueOf(getLoginTimeout())));
ref.add(new StringRefAddr(Constants.KEY_PASSWORD, getPassword()));
ref.add(new StringRefAddr(Constants.KEY_USER, getUser()));
ref.add(new StringRefAddr("url", getUrl()));
ref.add(new StringRefAddr("poolPreparedStatements", String.valueOf(isPoolPreparedStatements())));
ref.add(new StringRefAddr("maxIdle", String.valueOf(getMaxIdle())));
ref.add(new StringRefAddr("numTestsPerEvictionRun", String.valueOf(getNumTestsPerEvictionRun())));
ref.add(new StringRefAddr("maxPreparedStatements", String.valueOf(getMaxPreparedStatements())));
//
// Pair of current and deprecated.
ref.add(new StringRefAddr("durationBetweenEvictionRuns", String.valueOf(getDurationBetweenEvictionRuns())));
ref.add(new StringRefAddr("timeBetweenEvictionRunsMillis", String.valueOf(getTimeBetweenEvictionRunsMillis())));
//
// Pair of current and deprecated.
ref.add(new StringRefAddr("minEvictableIdleDuration", String.valueOf(getMinEvictableIdleDuration())));
ref.add(new StringRefAddr("minEvictableIdleTimeMillis", String.valueOf(getMinEvictableIdleTimeMillis())));
return ref;
}
private String getStringContent(final RefAddr ra) {
return ra.getContent().toString();
}
/**
* Gets 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.
*
* @return the value of the evictor thread timer
* @see #setDurationBetweenEvictionRuns(Duration)
* @deprecated Use {@link #getDurationBetweenEvictionRuns()}.
*/
@Deprecated
public long getTimeBetweenEvictionRunsMillis() {
return durationBetweenEvictionRuns.toMillis();
}
/**
* Gets the value of connection string used to locate the database for this data source.
*
* @return value of connection string.
*/
public String getUrl() {
return connectionString;
}
/**
* Gets the value of default user (login or user name).
*
* @return value of user.
*/
public String getUser() {
return userName;
}
/**
* Returns the value of the accessToUnderlyingConnectionAllowed property.
*
* @return true if access to the underlying is allowed, false otherwise.
*/
public synchronized boolean isAccessToUnderlyingConnectionAllowed() {
return this.accessToUnderlyingConnectionAllowed;
}
private boolean isNotEmpty(final RefAddr ra) {
return ra != null && ra.getContent() != null;
}
/**
* Whether to toggle the pooling of {@code PreparedStatement}s
*
* @return value of poolPreparedStatements.
*/
public boolean isPoolPreparedStatements() {
return poolPreparedStatements;
}
/**
* Sets the value of the accessToUnderlyingConnectionAllowed property. It controls if the PoolGuard allows access to
* the underlying connection. (Default: false)
*
* @param allow Access to the underlying connection is granted when true.
*/
public synchronized void setAccessToUnderlyingConnectionAllowed(final boolean allow) {
this.accessToUnderlyingConnectionAllowed = allow;
}
/**
* Sets the connection properties passed to the JDBC driver.
*
* If {@code props} contains "user" and/or "password" properties, the corresponding instance properties are
* set. If these properties are not present, they are filled in using {@link #getUser()}, {@link #getPassword()}
* when {@link #getPooledConnection()} is called, or using the actual parameters to the method call when
* {@link #getPooledConnection(String, String)} is called. Calls to {@link #setUser(String)} or
* {@link #setPassword(String)} overwrite the values of these properties if {@code connectionProperties} is not
* null.
*
*
* @param props Connection properties to use when creating new connections.
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setConnectionProperties(final Properties props) {
assertInitializationAllowed();
connectionProperties = props;
if (connectionProperties != null) {
final String user = connectionProperties.getProperty(Constants.KEY_USER);
if (user != null) {
setUser(user);
}
final String password = connectionProperties.getProperty(Constants.KEY_PASSWORD);
if (password != null) {
setPassword(password);
}
}
}
/**
* Sets the value of description. This property is here for use by the code which will deploy this datasource. It is
* not used internally.
*
* @param description Value to assign to description.
*/
public void setDescription(final String description) {
this.description = description;
}
/**
* Sets the driver class name. Setting the driver class name cause the driver to be registered with the
* DriverManager.
*
* @param driver Value to assign to driver.
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
* @throws ClassNotFoundException if the class cannot be located
*/
public void setDriver(final String driver) throws ClassNotFoundException {
assertInitializationAllowed();
this.driver = driver;
// make sure driver is registered
Class.forName(driver);
}
/**
* Sets the duration to sleep between runs of the idle object evictor thread. When non-positive, no
* idle object evictor thread will be run.
*
* @param durationBetweenEvictionRuns The duration to sleep between runs of the idle object evictor
* thread. When non-positive, no idle object evictor thread will be run.
* @see #getDurationBetweenEvictionRuns()
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
* @since 2.9.0
*/
public void setDurationBetweenEvictionRuns(final Duration durationBetweenEvictionRuns) {
assertInitializationAllowed();
this.durationBetweenEvictionRuns = durationBetweenEvictionRuns;
}
/**
* Sets the maximum time in seconds that this data source will wait while attempting to connect to a database. NOT
* USED.
*/
@Override
public void setLoginTimeout(final int seconds) {
this.loginTimeout = seconds;
}
/**
* Sets the log writer for this data source. NOT USED.
*/
@Override
public void setLogWriter(final PrintWriter logWriter) {
this.logWriter = logWriter;
}
/**
* Gets the maximum number of statements that can remain idle in the pool, without extra ones being released, or
* negative for no limit.
*
* @param maxIdle The maximum number of statements that can remain idle
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setMaxIdle(final int maxIdle) {
assertInitializationAllowed();
this.maxIdle = maxIdle;
}
/**
* Sets the maximum number of prepared statements.
*
* @param maxPreparedStatements the new maximum number of prepared statements
*/
public void setMaxPreparedStatements(final int maxPreparedStatements) {
this.maxPreparedStatements = maxPreparedStatements;
}
/**
* Sets the minimum amount of time a statement may sit idle in the pool before it is eligible for eviction by the
* idle object evictor (if any). When non-positive, no objects will be evicted from the pool due to idle time alone.
*
* @param minEvictableIdleDuration minimum time to set in milliseconds.
* @see #getMinEvictableIdleDuration()
* @see #setDurationBetweenEvictionRuns(Duration)
* @throws IllegalStateException if {@link #getPooledConnection()} has been called.
* @since 2.9.0
*/
public void setMinEvictableIdleDuration(final Duration minEvictableIdleDuration) {
assertInitializationAllowed();
this.minEvictableIdleDuration = minEvictableIdleDuration;
}
/**
* Sets the minimum amount of time a statement may sit idle in the pool before it is eligible for eviction by the
* idle object evictor (if any). When non-positive, no objects will be evicted from the pool due to idle time alone.
*
* @param minEvictableIdleTimeMillis minimum time to set in milliseconds.
* @see #getMinEvictableIdleDuration()
* @see #setDurationBetweenEvictionRuns(Duration)
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
* @deprecated Use {@link #setMinEvictableIdleDuration(Duration)}.
*/
@Deprecated
public void setMinEvictableIdleTimeMillis(final int minEvictableIdleTimeMillis) {
assertInitializationAllowed();
this.minEvictableIdleDuration = Duration.ofMillis(minEvictableIdleTimeMillis);
}
/**
* Sets the number of statements to examine during each run of the idle object evictor thread (if any).
*
* When a negative value is supplied,
* {@code ceil({@link BasicDataSource#getNumIdle})/abs({@link #getNumTestsPerEvictionRun})} tests will be run.
* I.e., when the value is -n, roughly one nth of the idle objects will be tested per run.
*
*
* @param numTestsPerEvictionRun number of statements to examine per run
* @see #getNumTestsPerEvictionRun()
* @see #setDurationBetweenEvictionRuns(Duration)
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setNumTestsPerEvictionRun(final int numTestsPerEvictionRun) {
assertInitializationAllowed();
this.numTestsPerEvictionRun = numTestsPerEvictionRun;
}
/**
* Sets the value of password for the default user.
*
* @param userPassword Value to assign to password.
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setPassword(final char[] userPassword) {
assertInitializationAllowed();
this.userPassword = Utils.clone(userPassword);
update(connectionProperties, Constants.KEY_PASSWORD, Utils.toString(this.userPassword));
}
/**
* Sets the value of password for the default user.
*
* @param userPassword Value to assign to password.
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setPassword(final String userPassword) {
assertInitializationAllowed();
this.userPassword = Utils.toCharArray(userPassword);
update(connectionProperties, Constants.KEY_PASSWORD, userPassword);
}
/**
* Whether to toggle the pooling of {@code PreparedStatement}s
*
* @param poolPreparedStatements true to pool statements.
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setPoolPreparedStatements(final boolean poolPreparedStatements) {
assertInitializationAllowed();
this.poolPreparedStatements = poolPreparedStatements;
}
/**
* Sets 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.
*
* @param 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.
* @see #getDurationBetweenEvictionRuns()
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
* @deprecated Use {@link #setDurationBetweenEvictionRuns(Duration)}.
*/
@Deprecated
public void setTimeBetweenEvictionRunsMillis(final long timeBetweenEvictionRunsMillis) {
assertInitializationAllowed();
this.durationBetweenEvictionRuns = Duration.ofMillis(timeBetweenEvictionRunsMillis);
}
/**
* Sets the value of URL string used to locate the database for this data source.
*
* @param connectionString Value to assign to connection string.
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setUrl(final String connectionString) {
assertInitializationAllowed();
this.connectionString = connectionString;
}
/**
* Sets the value of default user (login or user name).
*
* @param userName Value to assign to user.
* @throws IllegalStateException if {@link #getPooledConnection()} has been called
*/
public void setUser(final String userName) {
assertInitializationAllowed();
this.userName = userName;
update(connectionProperties, Constants.KEY_USER, userName);
}
/**
* Does not print the userName and userPassword field nor the 'user' or 'password' in the connectionProperties.
*
* @since 2.6.0
*/
@Override
public synchronized String toString() {
final StringBuilder builder = new StringBuilder(super.toString());
builder.append("[description=");
builder.append(description);
builder.append(", connectionString=");
// TODO What if the connection string contains a 'user' or 'password' query parameter but that connection string
// is not in a legal URL format?
builder.append(connectionString);
builder.append(", driver=");
builder.append(driver);
builder.append(", loginTimeout=");
builder.append(loginTimeout);
builder.append(", poolPreparedStatements=");
builder.append(poolPreparedStatements);
builder.append(", maxIdle=");
builder.append(maxIdle);
builder.append(", timeBetweenEvictionRunsMillis=");
builder.append(durationBetweenEvictionRuns);
builder.append(", numTestsPerEvictionRun=");
builder.append(numTestsPerEvictionRun);
builder.append(", minEvictableIdleTimeMillis=");
builder.append(minEvictableIdleDuration);
builder.append(", maxPreparedStatements=");
builder.append(maxPreparedStatements);
builder.append(", getConnectionCalled=");
builder.append(getConnectionCalled);
builder.append(", connectionProperties=");
builder.append(Utils.cloneWithoutCredentials(connectionProperties));
builder.append(", accessToUnderlyingConnectionAllowed=");
builder.append(accessToUnderlyingConnectionAllowed);
builder.append("]");
return builder.toString();
}
private void update(final Properties properties, final String key, final String value) {
if (properties != null && key != null) {
if (value == null) {
properties.remove(key);
} else {
properties.setProperty(key, value);
}
}
}
}
PStmtKeyCPDS.java 0000664 0000000 0000000 00000010343 14473117325 0033703 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/cpdsadapter /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.cpdsadapter;
import org.apache.commons.dbcp2.PStmtKey;
/**
* A key uniquely identifying a {@link java.sql.PreparedStatement PreparedStatement}.
*
* @since 2.0
* @deprecated Use {@link PStmtKey}.
*/
@Deprecated
public class PStmtKeyCPDS extends PStmtKey {
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql
* The SQL statement.
*/
public PStmtKeyCPDS(final String sql) {
super(sql);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql
* The SQL statement.
* @param autoGeneratedKeys
* A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
*/
public PStmtKeyCPDS(final String sql, final int autoGeneratedKeys) {
super(sql, null, autoGeneratedKeys);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql
* The SQL statement.
* @param resultSetType
* A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
*/
public PStmtKeyCPDS(final String sql, final int resultSetType, final int resultSetConcurrency) {
super(sql, resultSetType, resultSetConcurrency);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql
* The SQL statement.
* @param resultSetType
* a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}
* @param resultSetHoldability
* One of the following {@code ResultSet} constants: {@code ResultSet.HOLD_CURSORS_OVER_COMMIT}
* or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
*/
public PStmtKeyCPDS(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) {
super(sql, null, resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql
* The SQL statement.
* @param columnIndexes
* An array of column indexes indicating the columns that should be returned from the inserted row or
* rows.
*/
public PStmtKeyCPDS(final String sql, final int[] columnIndexes) {
super(sql, null, columnIndexes);
}
/**
* Constructs a key to uniquely identify a prepared statement.
*
* @param sql
* The SQL statement.
* @param columnNames
* An array of column names indicating the columns that should be returned from the inserted row or rows.
*/
public PStmtKeyCPDS(final String sql, final String[] columnNames) {
super(sql, null, columnNames);
}
}
PooledConnectionImpl.java 0000664 0000000 0000000 00000075327 14473117325 0035612 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/cpdsadapter /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.cpdsadapter;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.sql.ConnectionEvent;
import javax.sql.ConnectionEventListener;
import javax.sql.PooledConnection;
import javax.sql.StatementEventListener;
import org.apache.commons.dbcp2.DelegatingConnection;
import org.apache.commons.dbcp2.DelegatingPreparedStatement;
import org.apache.commons.dbcp2.Jdbc41Bridge;
import org.apache.commons.dbcp2.PStmtKey;
import org.apache.commons.dbcp2.PoolableCallableStatement;
import org.apache.commons.dbcp2.PoolablePreparedStatement;
import org.apache.commons.dbcp2.PoolingConnection.StatementType;
import org.apache.commons.dbcp2.Utils;
import org.apache.commons.pool2.KeyedObjectPool;
import org.apache.commons.pool2.KeyedPooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
/**
* Implementation of {@link PooledConnection} that is returned by {@link DriverAdapterCPDS}.
*
* @since 2.0
*/
final class PooledConnectionImpl
implements PooledConnection, KeyedPooledObjectFactory {
private static final String CLOSED = "Attempted to use PooledConnection after closed() was called.";
/**
* The JDBC database connection that represents the physical db connection.
*/
private Connection connection;
/**
* A DelegatingConnection used to create a PoolablePreparedStatementStub.
*/
private final DelegatingConnection delegatingConnection;
/**
* The JDBC database logical connection.
*/
private Connection logicalConnection;
/**
* ConnectionEventListeners.
*/
private final List eventListeners;
/**
* StatementEventListeners.
*/
private final List statementEventListeners = Collections.synchronizedList(new ArrayList<>());
/**
* Flag set to true, once {@link #close()} is called.
*/
private boolean closed;
/** My pool of {@link PreparedStatement}s. */
private KeyedObjectPool pStmtPool;
/**
* Controls access to the underlying connection.
*/
private boolean accessToUnderlyingConnectionAllowed;
/**
* Wraps the real connection.
*
* @param connection
* the connection to be wrapped.
*/
PooledConnectionImpl(final Connection connection) {
this.connection = connection;
if (connection instanceof DelegatingConnection) {
this.delegatingConnection = (DelegatingConnection) connection;
} else {
this.delegatingConnection = new DelegatingConnection<>(connection);
}
eventListeners = Collections.synchronizedList(new ArrayList<>());
closed = false;
}
/**
* My {@link KeyedPooledObjectFactory} method for activating {@link PreparedStatement}s.
*
* @param pooledObject Activates the underlying object.
*/
@Override
public void activateObject(final PStmtKey key, final PooledObject pooledObject)
throws SQLException {
pooledObject.getObject().activate();
}
/**
* {@inheritDoc}
*/
@Override
public void addConnectionEventListener(final ConnectionEventListener listener) {
if (!eventListeners.contains(listener)) {
eventListeners.add(listener);
}
}
@Override
public void addStatementEventListener(final StatementEventListener listener) {
if (!statementEventListeners.contains(listener)) {
statementEventListeners.add(listener);
}
}
/**
* Throws an SQLException, if isClosed is true
*/
private void assertOpen() throws SQLException {
if (closed || connection == null) {
throw new SQLException(CLOSED);
}
}
/**
* Closes the physical connection and marks this {@code PooledConnection} so that it may not be used to
* generate any more logical {@code Connection}s.
*
* @throws SQLException
* Thrown when an error occurs or the connection is already closed.
*/
@Override
public void close() throws SQLException {
assertOpen();
closed = true;
try {
if (pStmtPool != null) {
try {
pStmtPool.close();
} finally {
pStmtPool = null;
}
}
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Cannot close connection (return to pool failed)", e);
} finally {
try {
connection.close();
} finally {
connection = null;
}
}
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @return a {@link PStmtKey} for the given arguments.
*/
protected PStmtKey createKey(final String sql) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull());
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param autoGeneratedKeys
* A flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
* @return a key to uniquely identify a prepared statement.
*/
protected PStmtKey createKey(final String sql, final int autoGeneratedKeys) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), autoGeneratedKeys);
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param resultSetType
* A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @return a key to uniquely identify a prepared statement.
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency);
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param resultSetType
* a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}
* @param resultSetHoldability
* One of the following {@code ResultSet} constants: {@code ResultSet.HOLD_CURSORS_OVER_COMMIT}
* or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @return a key to uniquely identify a prepared statement.
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param resultSetType
* a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}
* @param resultSetConcurrency
* A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param resultSetHoldability
* One of the following {@code ResultSet} constants: {@code ResultSet.HOLD_CURSORS_OVER_COMMIT}
* or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @param statementType
* The SQL statement type, prepared or callable.
* @return a key to uniquely identify a prepared statement.
* @since 2.4.0
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability,
final StatementType statementType) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency, resultSetHoldability, statementType);
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param resultSetType
* A result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* A concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param statementType
* The SQL statement type, prepared or callable.
* @return a key to uniquely identify a prepared statement.
* @since 2.4.0
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency, final StatementType statementType) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), resultSetType, resultSetConcurrency, statementType);
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param columnIndexes
* An array of column indexes indicating the columns that should be returned from the inserted row or
* rows.
* @return a key to uniquely identify a prepared statement.
*/
protected PStmtKey createKey(final String sql, final int[] columnIndexes) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), columnIndexes);
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param statementType
* The SQL statement type, prepared or callable.
* @return a key to uniquely identify a prepared statement.
*/
protected PStmtKey createKey(final String sql, final StatementType statementType) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), statementType);
}
/**
* Creates a {@link PStmtKey} for the given arguments.
*
* @param sql
* The SQL statement.
* @param columnNames
* An array of column names indicating the columns that should be returned from the inserted row or rows.
* @return a key to uniquely identify a prepared statement.
*/
protected PStmtKey createKey(final String sql, final String[] columnNames) {
return new PStmtKey(sql, getCatalogOrNull(), getSchemaOrNull(), columnNames);
}
/**
* My {@link KeyedPooledObjectFactory} method for destroying {@link PreparedStatement}s.
*
* @param key
* ignored
* @param pooledObject
* the wrapped {@link PreparedStatement} to be destroyed.
*/
@Override
public void destroyObject(final PStmtKey key, final PooledObject pooledObject)
throws SQLException {
pooledObject.getObject().getInnermostDelegate().close();
}
/**
* Closes the physical connection and checks that the logical connection was closed as well.
*/
@Override
protected void finalize() throws Throwable {
// Closing the Connection ensures that if anyone tries to use it,
// an error will occur.
Utils.close(connection, null);
// make sure the last connection is marked as closed
if (logicalConnection != null && !logicalConnection.isClosed()) {
throw new SQLException("PooledConnection was gc'ed, without its last Connection being closed.");
}
}
private String getCatalogOrNull() {
try {
return connection == null ? null : connection.getCatalog();
} catch (final SQLException e) {
return null;
}
}
/**
* Returns a JDBC connection.
*
* @return The database connection.
* @throws SQLException
* if the connection is not open or the previous logical connection is still open
*/
@Override
public Connection getConnection() throws SQLException {
assertOpen();
// make sure the last connection is marked as closed
if (logicalConnection != null && !logicalConnection.isClosed()) {
// should notify pool of error so the pooled connection can
// be removed !FIXME!
throw new SQLException("PooledConnection was reused, without its previous Connection being closed.");
}
// the spec requires that this return a new Connection instance.
logicalConnection = new ConnectionImpl(this, connection, isAccessToUnderlyingConnectionAllowed());
return logicalConnection;
}
private Connection getRawConnection() throws SQLException {
assertOpen();
return connection;
}
private String getSchemaOrNull() {
try {
return connection == null ? null : Jdbc41Bridge.getSchema(connection);
} catch (final SQLException e) {
return null;
}
}
/**
* Returns the value of the accessToUnderlyingConnectionAllowed property.
*
* @return true if access to the underlying is allowed, false otherwise.
*/
public synchronized boolean isAccessToUnderlyingConnectionAllowed() {
return this.accessToUnderlyingConnectionAllowed;
}
/**
* My {@link KeyedPooledObjectFactory} method for creating {@link PreparedStatement}s.
*
* @param key
* The key for the {@link PreparedStatement} to be created.
*/
@SuppressWarnings("resource")
@Override
public PooledObject makeObject(final PStmtKey key) throws SQLException {
if (null == key) {
throw new IllegalArgumentException("Prepared statement key is null or invalid.");
}
if (key.getStmtType() == StatementType.PREPARED_STATEMENT) {
final PreparedStatement statement = (PreparedStatement) key.createStatement(connection);
@SuppressWarnings({"rawtypes", "unchecked" }) // Unable to find way to avoid this
final PoolablePreparedStatement pps = new PoolablePreparedStatement(statement, key, pStmtPool,
delegatingConnection);
return new DefaultPooledObject<>(pps);
}
final CallableStatement statement = (CallableStatement) key.createStatement(connection);
@SuppressWarnings("unchecked")
final PoolableCallableStatement pcs = new PoolableCallableStatement(statement, key, pStmtPool,
(DelegatingConnection) delegatingConnection);
return new DefaultPooledObject<>(pcs);
}
/**
* Sends a connectionClosed event.
*/
void notifyListeners() {
final ConnectionEvent event = new ConnectionEvent(this);
new ArrayList<>(eventListeners).forEach(listener -> listener.connectionClosed(event));
}
/**
* My {@link KeyedPooledObjectFactory} method for passivating {@link PreparedStatement}s. Currently, invokes
* {@link PreparedStatement#clearParameters}.
*
* @param key
* ignored
* @param pooledObject
* a wrapped {@link PreparedStatement}
*/
@Override
public void passivateObject(final PStmtKey key, final PooledObject pooledObject)
throws SQLException {
@SuppressWarnings("resource")
final DelegatingPreparedStatement dps = pooledObject.getObject();
dps.clearParameters();
dps.passivate();
}
/**
* Creates or obtains a {@link CallableStatement} from my pool.
*
* @param sql
* an SQL statement that may contain one or more '?' parameter placeholders. Typically, this statement is
* specified using JDBC call escape syntax.
* @return a default {@code CallableStatement} object containing the pre-compiled SQL statement.
* @throws SQLException
* Thrown if a database access error occurs or this method is called on a closed connection.
* @since 2.4.0
*/
@SuppressWarnings("resource") // getRawConnection() does not allocate
CallableStatement prepareCall(final String sql) throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareCall(sql);
}
try {
return (CallableStatement) pStmtPool.borrowObject(createKey(sql, StatementType.CALLABLE_STATEMENT));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareCall from pool failed", e);
}
}
/**
* Creates or obtains a {@link CallableStatement} from my pool.
*
* @param sql
* a {@code String} object that is the SQL statement to be sent to the database; may contain on or
* more '?' parameters.
* @param resultSetType
* a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* a concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @return a {@code CallableStatement} object containing the pre-compiled SQL statement that will produce
* {@code ResultSet} objects with the given type and concurrency.
* @throws SQLException
* Thrown if a database access error occurs, this method is called on a closed connection or the given
* parameters are not {@code ResultSet} constants indicating type and concurrency.
* @since 2.4.0
*/
@SuppressWarnings("resource") // getRawConnection() does not allocate
CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareCall(sql, resultSetType, resultSetConcurrency);
}
try {
return (CallableStatement) pStmtPool.borrowObject(
createKey(sql, resultSetType, resultSetConcurrency, StatementType.CALLABLE_STATEMENT));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareCall from pool failed", e);
}
}
/**
* Creates or obtains a {@link CallableStatement} from my pool.
*
* @param sql
* a {@code String} object that is the SQL statement to be sent to the database; may contain on or
* more '?' parameters.
* @param resultSetType
* one of the following {@code ResultSet} constants: {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* one of the following {@code ResultSet} constants: {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
* @param resultSetHoldability
* one of the following {@code ResultSet} constants: {@code ResultSet.HOLD_CURSORS_OVER_COMMIT}
* or {@code ResultSet.CLOSE_CURSORS_AT_COMMIT}.
* @return a new {@code CallableStatement} object, containing the pre-compiled SQL statement, that will
* generate {@code ResultSet} objects with the given type, concurrency, and holdability.
* @throws SQLException
* Thrown if a database access error occurs, this method is called on a closed connection or the given
* parameters are not {@code ResultSet} constants indicating type, concurrency, and holdability.
* @since 2.4.0
*/
@SuppressWarnings("resource") // getRawConnection() does not allocate
CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
try {
return (CallableStatement) pStmtPool.borrowObject(createKey(sql, resultSetType, resultSetConcurrency,
resultSetHoldability, StatementType.CALLABLE_STATEMENT));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareCall from pool failed", e);
}
}
/**
* Creates or obtains a {@link PreparedStatement} from my pool.
*
* @param sql the SQL statement.
* @return a {@link PoolablePreparedStatement}
* @throws SQLException Thrown if a database access error occurs, this method is called on a closed connection, or
* the borrow failed.
*/
@SuppressWarnings("resource") // getRawConnection() does not allocate
PreparedStatement prepareStatement(final String sql) throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareStatement(sql);
}
try {
return pStmtPool.borrowObject(createKey(sql));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
/**
* Creates or obtains a {@link PreparedStatement} from my pool.
*
* @param sql
* an SQL statement that may contain one or more '?' IN parameter placeholders.
* @param autoGeneratedKeys
* a flag indicating whether auto-generated keys should be returned; one of
* {@code Statement.RETURN_GENERATED_KEYS} or {@code Statement.NO_GENERATED_KEYS}.
* @return a {@link PoolablePreparedStatement}
* @throws SQLException Thrown if a database access error occurs, this method is called on a closed connection, or
* the borrow failed.
* @see Connection#prepareStatement(String, int)
*/
@SuppressWarnings("resource") // getRawConnection() does not allocate
PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareStatement(sql, autoGeneratedKeys);
}
try {
return pStmtPool.borrowObject(createKey(sql, autoGeneratedKeys));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
/**
* Creates or obtains a {@link PreparedStatement} from my pool.
*
* @param sql
* a {@code String} object that is the SQL statement to be sent to the database; may contain one or
* more '?' IN parameters.
* @param resultSetType
* a result set type; one of {@code ResultSet.TYPE_FORWARD_ONLY},
* {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code ResultSet.TYPE_SCROLL_SENSITIVE}.
* @param resultSetConcurrency
* a concurrency type; one of {@code ResultSet.CONCUR_READ_ONLY} or
* {@code ResultSet.CONCUR_UPDATABLE}.
*
* @return a {@link PoolablePreparedStatement}.
* @throws SQLException Thrown if a database access error occurs, this method is called on a closed connection, or
* the borrow failed.
* @see Connection#prepareStatement(String, int, int)
*/
@SuppressWarnings("resource") // getRawConnection() does not allocate
PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareStatement(sql, resultSetType, resultSetConcurrency);
}
try {
return pStmtPool.borrowObject(createKey(sql, resultSetType, resultSetConcurrency));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
@SuppressWarnings("resource") // getRawConnection() does not allocate
PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
final int resultSetHoldability) throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
try {
return pStmtPool.borrowObject(createKey(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
@SuppressWarnings("resource") // getRawConnection() does not allocate
PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareStatement(sql, columnIndexes);
}
try {
return pStmtPool.borrowObject(createKey(sql, columnIndexes));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
@SuppressWarnings("resource") // getRawConnection() does not allocate
PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
if (pStmtPool == null) {
return getRawConnection().prepareStatement(sql, columnNames);
}
try {
return pStmtPool.borrowObject(createKey(sql, columnNames));
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
/**
* {@inheritDoc}
*/
@Override
public void removeConnectionEventListener(final ConnectionEventListener listener) {
eventListeners.remove(listener);
}
@Override
public void removeStatementEventListener(final StatementEventListener listener) {
statementEventListeners.remove(listener);
}
/**
* Sets the value of the accessToUnderlyingConnectionAllowed property. It controls if the PoolGuard allows access to
* the underlying connection. (Default: false.)
*
* @param allow
* Access to the underlying connection is granted when true.
*/
public synchronized void setAccessToUnderlyingConnectionAllowed(final boolean allow) {
this.accessToUnderlyingConnectionAllowed = allow;
}
public void setStatementPool(final KeyedObjectPool statementPool) {
pStmtPool = statementPool;
}
/**
* @since 2.6.0
*/
@Override
public synchronized String toString() {
final StringBuilder builder = new StringBuilder(super.toString());
builder.append("[connection=");
builder.append(connection);
builder.append(", delegatingConnection=");
builder.append(delegatingConnection);
builder.append(", logicalConnection=");
builder.append(logicalConnection);
builder.append(", eventListeners=");
builder.append(eventListeners);
builder.append(", statementEventListeners=");
builder.append(statementEventListeners);
builder.append(", closed=");
builder.append(closed);
builder.append(", pStmtPool=");
builder.append(pStmtPool);
builder.append(", accessToUnderlyingConnectionAllowed=");
builder.append(accessToUnderlyingConnectionAllowed);
builder.append("]");
return builder.toString();
}
/**
* My {@link KeyedPooledObjectFactory} method for validating {@link PreparedStatement}s.
*
* @param key
* Ignored.
* @param pooledObject
* Ignored.
* @return {@code true}
*/
@Override
public boolean validateObject(final PStmtKey key, final PooledObject pooledObject) {
return true;
}
}
package-info.java 0000664 0000000 0000000 00000006016 14473117325 0034037 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/cpdsadapter /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
*
* This package contains one public class which is a
* {@code ConnectionPoolDataSource} (CPDS) implementation that can be used to
* adapt older {@code Driver} based JDBC implementations. Below is an
* example of setting up the CPDS to be available via JNDI in the
* catalina servlet container.
*
* In server.xml, the following would be added to the <Context> for your
* webapp:
*
*
*
* <Resource name="jdbc/bookstoreCPDS" auth="Container"
* type="org.apache.commons.dbcp2.cpdsadapter.DriverAdapterCPDS"/>
* <ResourceParams name="jdbc/bookstoreCPDS">
* <parameter>
* <name>factory</name>
* <value>org.apache.commons.dbcp2.cpdsadapter.DriverAdapterCPDS</value>
* </parameter>
* <parameter><name>user</name><value>root</value></parameter>
* <parameter><name>password</name><value></value></parameter>
* <parameter>
* <name>driver</name>
* <value>org.gjt.mm.mysql.Driver</value></parameter>
* <parameter>
* <name>url</name>
* <value>jdbc:mysql://localhost:3306/bookstore</value>
* </parameter>
* </ResourceParams>
*
*
*
* In web.xml. Note that elements must be given in the order of the dtd
* described in the servlet specification:
*
*
*
* <resource-ref>
* <description>
* Resource reference to a factory for java.sql.Connection
* instances that may be used for talking to a particular
* database that is configured in the server.xml file.
* </description>
* <res-ref-name>
* jdbc/bookstoreCPDS
* </res-ref-name>
* <res-type>
* org.apache.commons.dbcp2.cpdsadapter.DriverAdapterCPDS
* </res-type>
* <res-auth>
* Container
* </res-auth>
* </resource-ref>
*
*
*
* Catalina deploys all objects configured similarly to above within the
* java:comp/env namespace.
*
*/
package org.apache.commons.dbcp2.cpdsadapter;
commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/datasources/ 0000775 0000000 0000000 00000000000 14473117325 0030747 5 ustar 00root root 0000000 0000000 CPDSConnectionFactory.java 0000664 0000000 0000000 00000047632 14473117325 0035650 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/datasources /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.datasources;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.Duration;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.sql.ConnectionEvent;
import javax.sql.ConnectionEventListener;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import org.apache.commons.dbcp2.Utils;
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
/**
* A {@link PooledObjectFactory} that creates {@link org.apache.commons.dbcp2.PoolableConnection PoolableConnection}s.
*
* @since 2.0
*/
final class CPDSConnectionFactory
implements PooledObjectFactory, ConnectionEventListener, PooledConnectionManager {
private static final String NO_KEY_MESSAGE = "close() was called on a Connection, but I have no record of the underlying PooledConnection.";
private final ConnectionPoolDataSource cpds;
private final String validationQuery;
private final Duration validationQueryTimeoutDuration;
private final boolean rollbackAfterValidation;
private ObjectPool pool;
private UserPassKey userPassKey;
private Duration maxConnDuration = Duration.ofMillis(-1);
/**
* Map of PooledConnections for which close events are ignored. Connections are muted when they are being validated.
*/
private final Set validatingSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
/**
* Map of PooledConnectionAndInfo instances
*/
private final Map pcMap = new ConcurrentHashMap<>();
/**
* Creates a new {@code PoolableConnectionFactory}.
*
* @param cpds
* the ConnectionPoolDataSource from which to obtain PooledConnection's
* @param validationQuery
* a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one
* row. May be {@code null} in which case {@link Connection#isValid(int)} will be used to validate
* connections.
* @param validationQueryTimeoutDuration
* Timeout Duration before validation fails
* @param rollbackAfterValidation
* whether a rollback should be issued after {@link #validateObject validating} {@link Connection}s.
* @param userName
* The user name to use to create connections
* @param userPassword
* The password to use to create connections
* @since 2.10.0
*/
public CPDSConnectionFactory(final ConnectionPoolDataSource cpds, final String validationQuery,
final Duration validationQueryTimeoutDuration, final boolean rollbackAfterValidation, final String userName,
final char[] userPassword) {
this.cpds = cpds;
this.validationQuery = validationQuery;
this.validationQueryTimeoutDuration = validationQueryTimeoutDuration;
this.userPassKey = new UserPassKey(userName, userPassword);
this.rollbackAfterValidation = rollbackAfterValidation;
}
/**
* Creates a new {@code PoolableConnectionFactory}.
*
* @param cpds
* the ConnectionPoolDataSource from which to obtain PooledConnection's
* @param validationQuery
* a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one
* row. May be {@code null} in which case {@link Connection#isValid(int)} will be used to validate
* connections.
* @param validationQueryTimeoutDuration
* Timeout in seconds before validation fails
* @param rollbackAfterValidation
* whether a rollback should be issued after {@link #validateObject validating} {@link Connection}s.
* @param userName
* The user name to use to create connections
* @param userPassword
* The password to use to create connections
* @since 2.10.0
*/
public CPDSConnectionFactory(final ConnectionPoolDataSource cpds, final String validationQuery, final Duration validationQueryTimeoutDuration,
final boolean rollbackAfterValidation, final String userName, final String userPassword) {
this(cpds, validationQuery, validationQueryTimeoutDuration, rollbackAfterValidation, userName, Utils.toCharArray(userPassword));
}
/**
* Creates a new {@code PoolableConnectionFactory}.
*
* @param cpds
* the ConnectionPoolDataSource from which to obtain PooledConnection's
* @param validationQuery
* a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one
* row. May be {@code null} in which case {@link Connection#isValid(int)} will be used to validate
* connections.
* @param validationQueryTimeoutSeconds
* Timeout in seconds before validation fails
* @param rollbackAfterValidation
* whether a rollback should be issued after {@link #validateObject validating} {@link Connection}s.
* @param userName
* The user name to use to create connections
* @param userPassword
* The password to use to create connections
* @since 2.4.0
* @deprecated Use {@link #CPDSConnectionFactory(ConnectionPoolDataSource, String, Duration, boolean, String, char[])}.
*/
@Deprecated
public CPDSConnectionFactory(final ConnectionPoolDataSource cpds, final String validationQuery,
final int validationQueryTimeoutSeconds, final boolean rollbackAfterValidation, final String userName,
final char[] userPassword) {
this.cpds = cpds;
this.validationQuery = validationQuery;
this.validationQueryTimeoutDuration = Duration.ofSeconds(validationQueryTimeoutSeconds);
this.userPassKey = new UserPassKey(userName, userPassword);
this.rollbackAfterValidation = rollbackAfterValidation;
}
/**
* Creates a new {@code PoolableConnectionFactory}.
*
* @param cpds
* the ConnectionPoolDataSource from which to obtain PooledConnection's
* @param validationQuery
* a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one
* row. May be {@code null} in which case {@link Connection#isValid(int)} will be used to validate
* connections.
* @param validationQueryTimeoutSeconds
* Timeout in seconds before validation fails
* @param rollbackAfterValidation
* whether a rollback should be issued after {@link #validateObject validating} {@link Connection}s.
* @param userName
* The user name to use to create connections
* @param userPassword
* The password to use to create connections
* @deprecated Use {@link #CPDSConnectionFactory(ConnectionPoolDataSource, String, Duration, boolean, String, String)}.
*/
@Deprecated
public CPDSConnectionFactory(final ConnectionPoolDataSource cpds, final String validationQuery, final int validationQueryTimeoutSeconds,
final boolean rollbackAfterValidation, final String userName, final String userPassword) {
this(cpds, validationQuery, validationQueryTimeoutSeconds, rollbackAfterValidation, userName, Utils.toCharArray(userPassword));
}
@Override
public void activateObject(final PooledObject p) throws SQLException {
validateLifetime(p);
}
/**
* Verifies that the user name matches the user whose connections are being managed by this factory and closes the
* pool if this is the case; otherwise does nothing.
*/
@Override
public void closePool(final String userName) throws SQLException {
synchronized (this) {
if (userName == null || !userName.equals(this.userPassKey.getUserName())) {
return;
}
}
try {
pool.close();
} catch (final Exception ex) {
throw new SQLException("Error closing connection pool", ex);
}
}
/**
* This will be called if the Connection returned by the getConnection method came from a PooledConnection, and the
* user calls the close() method of this connection object. What we need to do here is to release this
* PooledConnection from our pool...
*/
@Override
public void connectionClosed(final ConnectionEvent event) {
final PooledConnection pc = (PooledConnection) event.getSource();
// if this event occurred because we were validating, ignore it
// otherwise return the connection to the pool.
if (!validatingSet.contains(pc)) {
final PooledConnectionAndInfo pci = pcMap.get(pc);
if (pci == null) {
throw new IllegalStateException(NO_KEY_MESSAGE);
}
try {
pool.returnObject(pci);
} catch (final Exception e) {
System.err.println("CLOSING DOWN CONNECTION AS IT COULD " + "NOT BE RETURNED TO THE POOL");
pc.removeConnectionEventListener(this);
try {
doDestroyObject(pci);
} catch (final Exception e2) {
System.err.println("EXCEPTION WHILE DESTROYING OBJECT " + pci);
e2.printStackTrace();
}
}
}
}
/**
* If a fatal error occurs, close the underlying physical connection so as not to be returned in the future
*/
@Override
public void connectionErrorOccurred(final ConnectionEvent event) {
final PooledConnection pc = (PooledConnection) event.getSource();
if (null != event.getSQLException()) {
System.err.println("CLOSING DOWN CONNECTION DUE TO INTERNAL ERROR (" + event.getSQLException() + ")");
}
pc.removeConnectionEventListener(this);
final PooledConnectionAndInfo pci = pcMap.get(pc);
if (pci == null) {
throw new IllegalStateException(NO_KEY_MESSAGE);
}
try {
pool.invalidateObject(pci);
} catch (final Exception e) {
System.err.println("EXCEPTION WHILE DESTROYING OBJECT " + pci);
e.printStackTrace();
}
}
/**
* Closes the PooledConnection and stops listening for events from it.
*/
@Override
public void destroyObject(final PooledObject p) throws SQLException {
doDestroyObject(p.getObject());
}
private void doDestroyObject(final PooledConnectionAndInfo pci) throws SQLException {
final PooledConnection pc = pci.getPooledConnection();
pc.removeConnectionEventListener(this);
pcMap.remove(pc);
pc.close();
}
/**
* (Testing API) Gets the value of password for the default user.
*
* @return value of password.
*/
char[] getPasswordCharArray() {
return userPassKey.getPasswordCharArray();
}
/**
* Returns the object pool used to pool connections created by this factory.
*
* @return ObjectPool managing pooled connections
*/
public ObjectPool getPool() {
return pool;
}
/**
* Invalidates the PooledConnection in the pool. The CPDSConnectionFactory closes the connection and pool counters
* are updated appropriately. Also closes the pool. This ensures that all idle connections are closed and
* connections that are checked out are closed on return.
*/
@Override
public void invalidate(final PooledConnection pc) throws SQLException {
final PooledConnectionAndInfo pci = pcMap.get(pc);
if (pci == null) {
throw new IllegalStateException(NO_KEY_MESSAGE);
}
try {
pool.invalidateObject(pci); // Destroy instance and update pool counters
pool.close(); // Clear any other instances in this pool and kill others as they come back
} catch (final Exception ex) {
throw new SQLException("Error invalidating connection", ex);
}
}
@Override
public synchronized PooledObject makeObject() throws SQLException {
PooledConnection pc = null;
if (userPassKey.getUserName() == null) {
pc = cpds.getPooledConnection();
} else {
pc = cpds.getPooledConnection(userPassKey.getUserName(), userPassKey.getPassword());
}
if (pc == null) {
throw new IllegalStateException("Connection pool data source returned null from getPooledConnection");
}
// should we add this object as a listener or the pool.
// consider the validateObject method in decision
pc.addConnectionEventListener(this);
final PooledConnectionAndInfo pci = new PooledConnectionAndInfo(pc, userPassKey);
pcMap.put(pc, pci);
return new DefaultPooledObject<>(pci);
}
@Override
public void passivateObject(final PooledObject p) throws SQLException {
validateLifetime(p);
}
/**
* Sets the maximum Duration of a connection after which the connection will always fail activation,
* passivation and validation.
*
* @param maxConnDuration
* A value of zero or less indicates an infinite lifetime. The default value is -1 milliseconds.
* @since 2.10.0
*/
public void setMaxConn(final Duration maxConnDuration) {
this.maxConnDuration = maxConnDuration;
}
/**
* Sets the maximum lifetime in milliseconds of a connection after which the connection will always fail activation,
* passivation and validation.
*
* @param maxConnDuration
* A value of zero or less indicates an infinite lifetime. The default value is -1 milliseconds.
* @since 2.9.0
* @deprecated Use {@link #setMaxConn(Duration)}.
*/
@Deprecated
public void setMaxConnLifetime(final Duration maxConnDuration) {
this.maxConnDuration = maxConnDuration;
}
/**
* Sets the maximum lifetime in milliseconds of a connection after which the connection will always fail activation,
* passivation and validation.
*
* @param maxConnLifetimeMillis
* A value of zero or less indicates an infinite lifetime. The default value is -1.
* @deprecated Use {@link #setMaxConn(Duration)}.
*/
@Deprecated
public void setMaxConnLifetimeMillis(final long maxConnLifetimeMillis) {
setMaxConnLifetime(Duration.ofMillis(maxConnLifetimeMillis));
}
/**
* Sets the database password used when creating new connections.
*
* @param userPassword
* new password
*/
public synchronized void setPassword(final char[] userPassword) {
this.userPassKey = new UserPassKey(userPassKey.getUserName(), userPassword);
}
/**
* Sets the database password used when creating new connections.
*
* @param userPassword
* new password
*/
@Override
public synchronized void setPassword(final String userPassword) {
this.userPassKey = new UserPassKey(userPassKey.getUserName(), userPassword);
}
/**
*
* @param pool
* the {@link ObjectPool} in which to pool those {@link Connection}s
*/
public void setPool(final ObjectPool pool) {
this.pool = pool;
}
/**
* @since 2.6.0
*/
@Override
public synchronized String toString() {
final StringBuilder builder = new StringBuilder(super.toString());
builder.append("[cpds=");
builder.append(cpds);
builder.append(", validationQuery=");
builder.append(validationQuery);
builder.append(", validationQueryTimeoutDuration=");
builder.append(validationQueryTimeoutDuration);
builder.append(", rollbackAfterValidation=");
builder.append(rollbackAfterValidation);
builder.append(", pool=");
builder.append(pool);
builder.append(", maxConnDuration=");
builder.append(maxConnDuration);
builder.append(", validatingSet=");
builder.append(validatingSet);
builder.append(", pcMap=");
builder.append(pcMap);
builder.append("]");
return builder.toString();
}
private void validateLifetime(final PooledObject p) throws SQLException {
Utils.validateLifetime(p, maxConnDuration);
}
@Override
public boolean validateObject(final PooledObject p) {
try {
validateLifetime(p);
} catch (final Exception e) {
return false;
}
boolean valid = false;
final PooledConnection pconn = p.getObject().getPooledConnection();
Connection conn = null;
validatingSet.add(pconn);
if (null == validationQuery) {
Duration timeoutDuration = validationQueryTimeoutDuration;
if (timeoutDuration.isNegative()) {
timeoutDuration = Duration.ZERO;
}
try {
conn = pconn.getConnection();
valid = conn.isValid((int) timeoutDuration.getSeconds());
} catch (final SQLException e) {
valid = false;
} finally {
Utils.closeQuietly((AutoCloseable) conn);
validatingSet.remove(pconn);
}
} else {
Statement stmt = null;
ResultSet rset = null;
// logical Connection from the PooledConnection must be closed
// before another one can be requested and closing it will
// generate an event. Keep track so we know not to return
// the PooledConnection
validatingSet.add(pconn);
try {
conn = pconn.getConnection();
stmt = conn.createStatement();
rset = stmt.executeQuery(validationQuery);
valid = rset.next();
if (rollbackAfterValidation) {
conn.rollback();
}
} catch (final Exception e) {
valid = false;
} finally {
Utils.closeQuietly((AutoCloseable) rset);
Utils.closeQuietly((AutoCloseable) stmt);
Utils.closeQuietly((AutoCloseable) conn);
validatingSet.remove(pconn);
}
}
return valid;
}
}
CharArray.java 0000664 0000000 0000000 00000004520 14473117325 0033410 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/datasources /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.datasources;
import java.io.Serializable;
import java.util.Arrays;
import org.apache.commons.dbcp2.Utils;
/**
* A {@code char} array wrapper that does not reveal its contents inadvertently through toString(). In contrast to, for
* example, AtomicReference which toString()'s its contents.
*
* May contain null.
*
* @since 2.9.0
*/
final class CharArray implements Serializable {
private static final long serialVersionUID = 1L;
static final CharArray NULL = new CharArray((char[]) null);
private final char[] chars;
CharArray(final char[] chars) {
this.chars = Utils.clone(chars);
}
CharArray(final String string) {
this.chars = Utils.toCharArray(string);
}
/**
* Converts the value of char array as a String.
*
* @return value as a string, may be null.
*/
String asString() {
return Utils.toString(chars);
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof CharArray)) {
return false;
}
final CharArray other = (CharArray) obj;
return Arrays.equals(chars, other.chars);
}
/**
* Gets the value of char array.
*
* @return value, may be null.
*/
char[] get() {
return Utils.clone(chars);
}
@Override
public int hashCode() {
return Arrays.hashCode(chars);
}
}
InstanceKeyDataSource.java 0000664 0000000 0000000 00000154155 14473117325 0035736 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/datasources /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.datasources;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.time.Duration;
import java.util.Properties;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.Referenceable;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.DataSource;
import javax.sql.PooledConnection;
import org.apache.commons.dbcp2.Utils;
import org.apache.commons.pool2.impl.BaseObjectPoolConfig;
import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
import org.apache.commons.pool2.impl.GenericObjectPool;
/**
*
* The base class for {@code SharedPoolDataSource} and {@code PerUserPoolDataSource}. Many of the
* configuration properties are shared and defined here. This class is declared public in order to allow particular
* usage with commons-beanutils; do not make direct use of it outside of commons-dbcp2.
*
*
*
* A J2EE container will normally provide some method of initializing the {@code DataSource} whose attributes are
* presented as bean getters/setters and then deploying it via JNDI. It is then available to an application as a source
* of pooled logical connections to the database. The pool needs a source of physical connections. This source is in the
* form of a {@code ConnectionPoolDataSource} that can be specified via the {@link #setDataSourceName(String)} used
* to lookup the source via JNDI.
*
*
*
* Although normally used within a JNDI environment, A DataSource can be instantiated and initialized as any bean. In
* this case the {@code ConnectionPoolDataSource} will likely be instantiated in a similar manner. This class
* allows the physical source of connections to be attached directly to this pool using the
* {@link #setConnectionPoolDataSource(ConnectionPoolDataSource)} method.
*
*
*
* The dbcp package contains an adapter, {@link org.apache.commons.dbcp2.cpdsadapter.DriverAdapterCPDS}, that can be
* used to allow the use of {@code DataSource}'s based on this class with JDBC driver implementations that do not
* supply a {@code ConnectionPoolDataSource}, but still provide a {@link java.sql.Driver} implementation.
*
*
*
* The package documentation contains an example using Apache Tomcat and JNDI and it
* also contains a non-JNDI example.
*
*
* @since 2.0
*/
public abstract class InstanceKeyDataSource implements DataSource, Referenceable, Serializable, AutoCloseable {
private static final long serialVersionUID = -6819270431752240878L;
private static final String GET_CONNECTION_CALLED = "A Connection was already requested from this source, "
+ "further initialization is not allowed.";
private static final String BAD_TRANSACTION_ISOLATION = "The requested TransactionIsolation level is invalid.";
/**
* Internal constant to indicate the level is not set.
*/
protected static final int UNKNOWN_TRANSACTIONISOLATION = -1;
/** Guards property setters - once true, setters throw IllegalStateException */
private volatile boolean getConnectionCalled;
/** Underlying source of PooledConnections */
private ConnectionPoolDataSource dataSource;
/** DataSource Name used to find the ConnectionPoolDataSource */
private String dataSourceName;
/** Description */
private String description;
/** Environment that may be used to set up a JNDI initial context. */
private Properties jndiEnvironment;
/** Login Timeout */
private Duration loginTimeoutDuration = Duration.ZERO;
/** Log stream */
private PrintWriter logWriter;
/** Instance key */
private String instanceKey;
// Pool properties
private boolean defaultBlockWhenExhausted = BaseObjectPoolConfig.DEFAULT_BLOCK_WHEN_EXHAUSTED;
private String defaultEvictionPolicyClassName = BaseObjectPoolConfig.DEFAULT_EVICTION_POLICY_CLASS_NAME;
private boolean defaultLifo = BaseObjectPoolConfig.DEFAULT_LIFO;
private int defaultMaxIdle = GenericKeyedObjectPoolConfig.DEFAULT_MAX_IDLE_PER_KEY;
private int defaultMaxTotal = GenericKeyedObjectPoolConfig.DEFAULT_MAX_TOTAL;
private Duration defaultMaxWaitDuration = BaseObjectPoolConfig.DEFAULT_MAX_WAIT;
private Duration defaultMinEvictableIdleDuration = BaseObjectPoolConfig.DEFAULT_MIN_EVICTABLE_IDLE_DURATION;
private int defaultMinIdle = GenericKeyedObjectPoolConfig.DEFAULT_MIN_IDLE_PER_KEY;
private int defaultNumTestsPerEvictionRun = BaseObjectPoolConfig.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
private Duration defaultSoftMinEvictableIdleDuration = BaseObjectPoolConfig.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_DURATION;
private boolean defaultTestOnCreate = BaseObjectPoolConfig.DEFAULT_TEST_ON_CREATE;
private boolean defaultTestOnBorrow = BaseObjectPoolConfig.DEFAULT_TEST_ON_BORROW;
private boolean defaultTestOnReturn = BaseObjectPoolConfig.DEFAULT_TEST_ON_RETURN;
private boolean defaultTestWhileIdle = BaseObjectPoolConfig.DEFAULT_TEST_WHILE_IDLE;
private Duration defaultDurationBetweenEvictionRuns = BaseObjectPoolConfig.DEFAULT_TIME_BETWEEN_EVICTION_RUNS;
// Connection factory properties
private String validationQuery;
private Duration validationQueryTimeoutDuration = Duration.ofSeconds(-1);
private boolean rollbackAfterValidation;
private Duration maxConnDuration = Duration.ofMillis(-1);
// Connection properties
private Boolean defaultAutoCommit;
private int defaultTransactionIsolation = UNKNOWN_TRANSACTIONISOLATION;
private Boolean defaultReadOnly;
/**
* Default no-arg constructor for Serialization.
*/
public InstanceKeyDataSource() {
}
/**
* Throws an IllegalStateException, if a PooledConnection has already been requested.
*
* @throws IllegalStateException Thrown if a PooledConnection has already been requested.
*/
protected void assertInitializationAllowed() throws IllegalStateException {
if (getConnectionCalled) {
throw new IllegalStateException(GET_CONNECTION_CALLED);
}
}
/**
* Closes the connection pool being maintained by this datasource.
*/
@Override
public abstract void close() throws SQLException;
private void closeDueToException(final PooledConnectionAndInfo info) {
if (info != null) {
try {
info.getPooledConnection().getConnection().close();
} catch (final Exception e) {
// do not throw this exception because we are in the middle
// of handling another exception. But record it because
// it potentially leaks connections from the pool.
getLogWriter().println("[ERROR] Could not return connection to pool during exception handling. " + e.getMessage());
}
}
}
/**
* Attempts to establish a database connection.
*/
@Override
public Connection getConnection() throws SQLException {
return getConnection(null, null);
}
/**
* Attempts to retrieve a database connection using {@link #getPooledConnectionAndInfo(String, String)} with the
* provided user name and password. The password on the {@code PooledConnectionAndInfo} instance returned by
* {@code getPooledConnectionAndInfo} is compared to the {@code password} parameter. If the comparison
* fails, a database connection using the supplied user name and password is attempted. If the connection attempt
* fails, an SQLException is thrown, indicating that the given password did not match the password used to create
* the pooled connection. If the connection attempt succeeds, this means that the database password has been
* changed. In this case, the {@code PooledConnectionAndInfo} instance retrieved with the old password is
* destroyed and the {@code getPooledConnectionAndInfo} is repeatedly invoked until a
* {@code PooledConnectionAndInfo} instance with the new password is returned.
*/
@Override
public Connection getConnection(final String userName, final String userPassword) throws SQLException {
if (instanceKey == null) {
throw new SQLException("Must set the ConnectionPoolDataSource "
+ "through setDataSourceName or setConnectionPoolDataSource" + " before calling getConnection.");
}
getConnectionCalled = true;
PooledConnectionAndInfo info = null;
try {
info = getPooledConnectionAndInfo(userName, userPassword);
} catch (final RuntimeException | SQLException e) {
closeDueToException(info);
throw e;
} catch (final Exception e) {
closeDueToException(info);
throw new SQLException("Cannot borrow connection from pool", e);
}
// Password on PooledConnectionAndInfo does not match
if (!(null == userPassword ? null == info.getPassword() : userPassword.equals(info.getPassword()))) {
try { // See if password has changed by attempting connection
testCPDS(userName, userPassword);
} catch (final SQLException ex) {
// Password has not changed, so refuse client, but return connection to the pool
closeDueToException(info);
throw new SQLException(
"Given password did not match password used" + " to create the PooledConnection.", ex);
} catch (final javax.naming.NamingException ne) {
throw new SQLException("NamingException encountered connecting to database", ne);
}
/*
* Password must have changed -> destroy connection and keep retrying until we get a new, good one,
* destroying any idle connections with the old password as we pull them from the pool.
*/
final UserPassKey upkey = info.getUserPassKey();
final PooledConnectionManager manager = getConnectionManager(upkey);
// Destroy and remove from pool
manager.invalidate(info.getPooledConnection());
// Reset the password on the factory if using CPDSConnectionFactory
manager.setPassword(upkey.getPassword());
info = null;
for (int i = 0; i < 10; i++) { // Bound the number of retries - only needed if bad instances return
try {
info = getPooledConnectionAndInfo(userName, userPassword);
} catch (final RuntimeException | SQLException e) {
closeDueToException(info);
throw e;
} catch (final Exception e) {
closeDueToException(info);
throw new SQLException("Cannot borrow connection from pool", e);
}
if (info != null && userPassword != null && userPassword.equals(info.getPassword())) {
break;
}
if (info != null) {
manager.invalidate(info.getPooledConnection());
}
info = null;
}
if (info == null) {
throw new SQLException("Cannot borrow connection from pool - password change failure.");
}
}
final Connection connection = info.getPooledConnection().getConnection();
try {
setupDefaults(connection, userName);
connection.clearWarnings();
return connection;
} catch (final SQLException ex) {
Utils.close(connection, e -> getLogWriter().println("ignoring exception during close: " + e));
throw ex;
}
}
protected abstract PooledConnectionManager getConnectionManager(UserPassKey upkey);
/**
* Gets the value of connectionPoolDataSource. This method will return null, if the backing data source is being
* accessed via JNDI.
*
* @return value of connectionPoolDataSource.
*/
public ConnectionPoolDataSource getConnectionPoolDataSource() {
return dataSource;
}
/**
* Gets the name of the ConnectionPoolDataSource which backs this pool. This name is used to look up the data source
* from a JNDI service provider.
*
* @return value of dataSourceName.
*/
public String getDataSourceName() {
return dataSourceName;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getBlockWhenExhausted()} for each per user pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getBlockWhenExhausted()} for each per user
* pool.
*/
public boolean getDefaultBlockWhenExhausted() {
return this.defaultBlockWhenExhausted;
}
/**
* Gets the default value for {@link GenericObjectPool#getDurationBetweenEvictionRuns()} for each per user pool.
*
* @return The default value for {@link GenericObjectPool#getDurationBetweenEvictionRuns()} for each per user pool.
* @since 2.10.0
*/
public Duration getDefaultDurationBetweenEvictionRuns() {
return this.defaultDurationBetweenEvictionRuns;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getEvictionPolicyClassName()} for each per user
* pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getEvictionPolicyClassName()} for each per user
* pool.
*/
public String getDefaultEvictionPolicyClassName() {
return this.defaultEvictionPolicyClassName;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getLifo()} for each per user pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getLifo()} for each per user pool.
*/
public boolean getDefaultLifo() {
return this.defaultLifo;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getMaxIdlePerKey()} for each per user pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getMaxIdlePerKey()} for each per user pool.
*/
public int getDefaultMaxIdle() {
return this.defaultMaxIdle;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getMaxTotalPerKey()} for each per user pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getMaxTotalPerKey()} for each per user pool.
*/
public int getDefaultMaxTotal() {
return this.defaultMaxTotal;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitDuration()} for each per user pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitDuration()} for each per user pool.
* @since 2.9.0
*/
public Duration getDefaultMaxWait() {
return this.defaultMaxWaitDuration;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitDuration()} for each per user pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitDuration()} for each per user pool.
* @deprecated Use {@link #getDefaultMaxWait()}.
*/
@Deprecated
public long getDefaultMaxWaitMillis() {
return getDefaultMaxWait().toMillis();
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each per user
* pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each per
* user pool.
* @since 2.10.0
*/
public Duration getDefaultMinEvictableIdleDuration() {
return this.defaultMinEvictableIdleDuration;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each per user
* pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each per
* user pool.
* @deprecated Use {@link #getDefaultMinEvictableIdleDuration()}.
*/
@Deprecated
public long getDefaultMinEvictableIdleTimeMillis() {
return this.defaultMinEvictableIdleDuration.toMillis();
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getMinIdlePerKey()} for each per user pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getMinIdlePerKey()} for each per user pool.
*/
public int getDefaultMinIdle() {
return this.defaultMinIdle;
}
/**
* Gets the default value for {@link GenericKeyedObjectPoolConfig#getNumTestsPerEvictionRun()} for each per user
* pool.
*
* @return The default value for {@link GenericKeyedObjectPoolConfig#getNumTestsPerEvictionRun()} for each per user
* pool.
*/
public int getDefaultNumTestsPerEvictionRun() {
return this.defaultNumTestsPerEvictionRun;
}
/**
* Gets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
*
* @return The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
* @since 2.10.0
*/
public Duration getDefaultSoftMinEvictableIdleDuration() {
return this.defaultSoftMinEvictableIdleDuration;
}
/**
* Gets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
*
* @return The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
* @deprecated Use {@link #getDefaultSoftMinEvictableIdleDuration()}.
*/
@Deprecated
public long getDefaultSoftMinEvictableIdleTimeMillis() {
return this.defaultSoftMinEvictableIdleDuration.toMillis();
}
/**
* Gets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnBorrow()} for each per user pool.
*
* @return The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnBorrow()} for each per user pool.
*/
public boolean getDefaultTestOnBorrow() {
return this.defaultTestOnBorrow;
}
/**
* Gets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnCreate()} for each per user pool.
*
* @return The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnCreate()} for each per user pool.
*/
public boolean getDefaultTestOnCreate() {
return this.defaultTestOnCreate;
}
/**
* Gets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnReturn()} for each per user pool.
*
* @return The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnReturn()} for each per user pool.
*/
public boolean getDefaultTestOnReturn() {
return this.defaultTestOnReturn;
}
/**
* Gets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestWhileIdle()} for each per user pool.
*
* @return The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestWhileIdle()} for each per user pool.
*/
public boolean getDefaultTestWhileIdle() {
return this.defaultTestWhileIdle;
}
/**
* Gets the default value for {@link GenericObjectPool#getDurationBetweenEvictionRuns ()} for each per user pool.
*
* @return The default value for {@link GenericObjectPool#getDurationBetweenEvictionRuns ()} for each per user pool.
* @deprecated Use {@link #getDefaultDurationBetweenEvictionRuns()}.
*/
@Deprecated
public long getDefaultTimeBetweenEvictionRunsMillis() {
return this.defaultDurationBetweenEvictionRuns.toMillis();
}
/**
* Gets the value of defaultTransactionIsolation, which defines the state of connections handed out from this pool.
* The value can be changed on the Connection using Connection.setTransactionIsolation(int). If this method returns
* -1, the default is JDBC driver dependent.
*
* @return value of defaultTransactionIsolation.
*/
public int getDefaultTransactionIsolation() {
return defaultTransactionIsolation;
}
/**
* Gets the description. This property is defined by JDBC as for use with GUI (or other) tools that might deploy the
* datasource. It serves no internal purpose.
*
* @return value of description.
*/
public String getDescription() {
return description;
}
/**
* Gets the instance key.
*
* @return the instance key.
*/
protected String getInstanceKey() {
return instanceKey;
}
/**
* Gets the value of jndiEnvironment which is used when instantiating a JNDI InitialContext. This InitialContext is
* used to locate the back end ConnectionPoolDataSource.
*
* @param key
* JNDI environment key.
* @return value of jndiEnvironment.
*/
public String getJndiEnvironment(final String key) {
String value = null;
if (jndiEnvironment != null) {
value = jndiEnvironment.getProperty(key);
}
return value;
}
/**
* Gets the value of loginTimeout.
*
* @return value of loginTimeout.
* @deprecated Use {@link #getLoginTimeoutDuration()}.
*/
@Deprecated
@Override
public int getLoginTimeout() {
return (int) loginTimeoutDuration.getSeconds();
}
/**
* Gets the value of loginTimeout.
*
* @return value of loginTimeout.
* @since 2.10.0
*/
public Duration getLoginTimeoutDuration() {
return loginTimeoutDuration;
}
/**
* Gets the value of logWriter.
*
* @return value of logWriter.
*/
@Override
public PrintWriter getLogWriter() {
if (logWriter == null) {
logWriter = new PrintWriter(new OutputStreamWriter(System.out, StandardCharsets.UTF_8));
}
return logWriter;
}
/**
* Gets the maximum permitted lifetime of a connection. A value of zero or less indicates an
* infinite lifetime.
*
* @return The maximum permitted lifetime of a connection. A value of zero or less indicates an
* infinite lifetime.
* @since 2.10.0
*/
public Duration getMaxConnDuration() {
return maxConnDuration;
}
/**
* Gets the maximum permitted lifetime of a connection. A value of zero or less indicates an
* infinite lifetime.
*
* @return The maximum permitted lifetime of a connection. A value of zero or less indicates an
* infinite lifetime.
* @deprecated Use {@link #getMaxConnDuration()}.
*/
@Deprecated
public Duration getMaxConnLifetime() {
return maxConnDuration;
}
/**
* Gets the maximum permitted lifetime of a connection in milliseconds. A value of zero or less indicates an
* infinite lifetime.
*
* @return The maximum permitted lifetime of a connection in milliseconds. A value of zero or less indicates an
* infinite lifetime.
* @deprecated Use {@link #getMaxConnLifetime()}.
*/
@Deprecated
public long getMaxConnLifetimeMillis() {
return maxConnDuration.toMillis();
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new SQLFeatureNotSupportedException();
}
/**
* This method is protected but can only be implemented in this package because PooledConnectionAndInfo is a package
* private type.
*
* @param userName The user name.
* @param userPassword The user password.
* @return Matching PooledConnectionAndInfo.
* @throws SQLException Connection or registration failure.
*/
protected abstract PooledConnectionAndInfo getPooledConnectionAndInfo(String userName, String userPassword)
throws SQLException;
/**
* Gets 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, {@link Connection#isValid(int)} will be used to validate connections.
*
* @return The SQL query that will be used to validate connections from this pool before returning them to the
* caller.
*/
public String getValidationQuery() {
return this.validationQuery;
}
/**
* Returns the timeout in seconds before the validation query fails.
*
* @return The timeout in seconds before the validation query fails.
* @deprecated Use {@link #getValidationQueryTimeoutDuration()}.
*/
@Deprecated
public int getValidationQueryTimeout() {
return (int) validationQueryTimeoutDuration.getSeconds();
}
/**
* Returns the timeout Duration before the validation query fails.
*
* @return The timeout Duration before the validation query fails.
*/
public Duration getValidationQueryTimeoutDuration() {
return validationQueryTimeoutDuration;
}
/**
* Gets the value of defaultAutoCommit, which defines the state of connections handed out from this pool. The value
* can be changed on the Connection using Connection.setAutoCommit(boolean). The default is {@code null} which
* will use the default value for the drive.
*
* @return value of defaultAutoCommit.
*/
public Boolean isDefaultAutoCommit() {
return defaultAutoCommit;
}
/**
* Gets the value of defaultReadOnly, which defines the state of connections handed out from this pool. The value
* can be changed on the Connection using Connection.setReadOnly(boolean). The default is {@code null} which
* will use the default value for the drive.
*
* @return value of defaultReadOnly.
*/
public Boolean isDefaultReadOnly() {
return defaultReadOnly;
}
/**
* Whether a rollback will be issued after executing the SQL query that will be used to validate connections from
* this pool before returning them to the caller.
*
* @return true if a rollback will be issued after executing the validation query
*/
public boolean isRollbackAfterValidation() {
return this.rollbackAfterValidation;
}
@Override
public boolean isWrapperFor(final Class iface) throws SQLException {
return iface.isInstance(this);
}
/**
* Sets the back end ConnectionPoolDataSource. This property should not be set if using JNDI to access the
* data source.
*
* @param dataSource
* Value to assign to connectionPoolDataSource.
*/
public void setConnectionPoolDataSource(final ConnectionPoolDataSource dataSource) {
assertInitializationAllowed();
if (dataSourceName != null) {
throw new IllegalStateException("Cannot set the DataSource, if JNDI is used.");
}
if (this.dataSource != null) {
throw new IllegalStateException("The CPDS has already been set. It cannot be altered.");
}
this.dataSource = dataSource;
instanceKey = InstanceKeyDataSourceFactory.registerNewInstance(this);
}
/**
* Sets the name of the ConnectionPoolDataSource which backs this pool. This name is used to look up the data source
* from a JNDI service provider.
*
* @param dataSourceName
* Value to assign to dataSourceName.
*/
public void setDataSourceName(final String dataSourceName) {
assertInitializationAllowed();
if (dataSource != null) {
throw new IllegalStateException("Cannot set the JNDI name for the DataSource, if already "
+ "set using setConnectionPoolDataSource.");
}
if (this.dataSourceName != null) {
throw new IllegalStateException("The DataSourceName has already been set. " + "It cannot be altered.");
}
this.dataSourceName = dataSourceName;
instanceKey = InstanceKeyDataSourceFactory.registerNewInstance(this);
}
/**
* Sets the value of defaultAutoCommit, which defines the state of connections handed out from this pool. The value
* can be changed on the Connection using Connection.setAutoCommit(boolean). The default is {@code null} which
* will use the default value for the drive.
*
* @param defaultAutoCommit
* Value to assign to defaultAutoCommit.
*/
public void setDefaultAutoCommit(final Boolean defaultAutoCommit) {
assertInitializationAllowed();
this.defaultAutoCommit = defaultAutoCommit;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getBlockWhenExhausted()} for each per user pool.
*
* @param blockWhenExhausted
* The default value for {@link GenericKeyedObjectPoolConfig#getBlockWhenExhausted()} for each per user
* pool.
*/
public void setDefaultBlockWhenExhausted(final boolean blockWhenExhausted) {
assertInitializationAllowed();
this.defaultBlockWhenExhausted = blockWhenExhausted;
}
/**
* Sets the default value for {@link GenericObjectPool#getDurationBetweenEvictionRuns ()} for each per user pool.
*
* @param defaultDurationBetweenEvictionRuns The default value for
* {@link GenericObjectPool#getDurationBetweenEvictionRuns ()} for each per user pool.
* @since 2.10.0
*/
public void setDefaultDurationBetweenEvictionRuns(final Duration defaultDurationBetweenEvictionRuns) {
assertInitializationAllowed();
this.defaultDurationBetweenEvictionRuns = defaultDurationBetweenEvictionRuns;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getEvictionPolicyClassName()} for each per user
* pool.
*
* @param evictionPolicyClassName
* The default value for {@link GenericKeyedObjectPoolConfig#getEvictionPolicyClassName()} for each per
* user pool.
*/
public void setDefaultEvictionPolicyClassName(final String evictionPolicyClassName) {
assertInitializationAllowed();
this.defaultEvictionPolicyClassName = evictionPolicyClassName;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getLifo()} for each per user pool.
*
* @param lifo
* The default value for {@link GenericKeyedObjectPoolConfig#getLifo()} for each per user pool.
*/
public void setDefaultLifo(final boolean lifo) {
assertInitializationAllowed();
this.defaultLifo = lifo;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getMaxIdlePerKey()} for each per user pool.
*
* @param maxIdle
* The default value for {@link GenericKeyedObjectPoolConfig#getMaxIdlePerKey()} for each per user pool.
*/
public void setDefaultMaxIdle(final int maxIdle) {
assertInitializationAllowed();
this.defaultMaxIdle = maxIdle;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getMaxTotalPerKey()} for each per user pool.
*
* @param maxTotal
* The default value for {@link GenericKeyedObjectPoolConfig#getMaxTotalPerKey()} for each per user pool.
*/
public void setDefaultMaxTotal(final int maxTotal) {
assertInitializationAllowed();
this.defaultMaxTotal = maxTotal;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitDuration()} for each per user pool.
*
* @param maxWaitMillis
* The default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitDuration()} for each per user pool.
* @since 2.9.0
*/
public void setDefaultMaxWait(final Duration maxWaitMillis) {
assertInitializationAllowed();
this.defaultMaxWaitDuration = maxWaitMillis;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitMillis()} for each per user pool.
*
* @param maxWaitMillis
* The default value for {@link GenericKeyedObjectPoolConfig#getMaxWaitMillis()} for each per user pool.
* @deprecated Use {@link #setDefaultMaxWait(Duration)}.
*/
@Deprecated
public void setDefaultMaxWaitMillis(final long maxWaitMillis) {
setDefaultMaxWait(Duration.ofMillis(maxWaitMillis));
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each per user
* pool.
*
* @param defaultMinEvictableIdleDuration
* The default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each
* per user pool.
* @since 2.10.0
*/
public void setDefaultMinEvictableIdle(final Duration defaultMinEvictableIdleDuration) {
assertInitializationAllowed();
this.defaultMinEvictableIdleDuration = defaultMinEvictableIdleDuration;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each per user
* pool.
*
* @param minEvictableIdleTimeMillis
* The default value for {@link GenericKeyedObjectPoolConfig#getMinEvictableIdleDuration()} for each
* per user pool.
* @deprecated Use {@link #setDefaultMinEvictableIdle(Duration)}.
*/
@Deprecated
public void setDefaultMinEvictableIdleTimeMillis(final long minEvictableIdleTimeMillis) {
assertInitializationAllowed();
this.defaultMinEvictableIdleDuration = Duration.ofMillis(minEvictableIdleTimeMillis);
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getMinIdlePerKey()} for each per user pool.
*
* @param minIdle
* The default value for {@link GenericKeyedObjectPoolConfig#getMinIdlePerKey()} for each per user pool.
*/
public void setDefaultMinIdle(final int minIdle) {
assertInitializationAllowed();
this.defaultMinIdle = minIdle;
}
/**
* Sets the default value for {@link GenericKeyedObjectPoolConfig#getNumTestsPerEvictionRun()} for each per user
* pool.
*
* @param numTestsPerEvictionRun
* The default value for {@link GenericKeyedObjectPoolConfig#getNumTestsPerEvictionRun()} for each per
* user pool.
*/
public void setDefaultNumTestsPerEvictionRun(final int numTestsPerEvictionRun) {
assertInitializationAllowed();
this.defaultNumTestsPerEvictionRun = numTestsPerEvictionRun;
}
/**
* Sets the value of defaultReadOnly, which defines the state of connections handed out from this pool. The value
* can be changed on the Connection using Connection.setReadOnly(boolean). The default is {@code null} which
* will use the default value for the drive.
*
* @param defaultReadOnly
* Value to assign to defaultReadOnly.
*/
public void setDefaultReadOnly(final Boolean defaultReadOnly) {
assertInitializationAllowed();
this.defaultReadOnly = defaultReadOnly;
}
/**
* Sets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
*
* @param defaultSoftMinEvictableIdleDuration
* The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
* @since 2.10.0
*/
public void setDefaultSoftMinEvictableIdle(final Duration defaultSoftMinEvictableIdleDuration) {
assertInitializationAllowed();
this.defaultSoftMinEvictableIdleDuration = defaultSoftMinEvictableIdleDuration;
}
/**
* Sets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
*
* @param softMinEvictableIdleTimeMillis
* The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getSoftMinEvictableIdleTimeMillis()} for each per user pool.
* @deprecated Use {@link #setDefaultSoftMinEvictableIdle(Duration)}.
*/
@Deprecated
public void setDefaultSoftMinEvictableIdleTimeMillis(final long softMinEvictableIdleTimeMillis) {
assertInitializationAllowed();
this.defaultSoftMinEvictableIdleDuration = Duration.ofMillis(softMinEvictableIdleTimeMillis);
}
/**
* Sets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnBorrow()} for each per user pool.
*
* @param testOnBorrow
* The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnBorrow()} for each per user pool.
*/
public void setDefaultTestOnBorrow(final boolean testOnBorrow) {
assertInitializationAllowed();
this.defaultTestOnBorrow = testOnBorrow;
}
/**
* Sets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnCreate()} for each per user pool.
*
* @param testOnCreate
* The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnCreate()} for each per user pool.
*/
public void setDefaultTestOnCreate(final boolean testOnCreate) {
assertInitializationAllowed();
this.defaultTestOnCreate = testOnCreate;
}
/**
* Sets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnReturn()} for each per user pool.
*
* @param testOnReturn
* The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestOnReturn()} for each per user pool.
*/
public void setDefaultTestOnReturn(final boolean testOnReturn) {
assertInitializationAllowed();
this.defaultTestOnReturn = testOnReturn;
}
/**
* Sets the default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestWhileIdle()} for each per user pool.
*
* @param testWhileIdle
* The default value for {@link org.apache.commons.pool2.impl.GenericObjectPool
* GenericObjectPool#getTestWhileIdle()} for each per user pool.
*/
public void setDefaultTestWhileIdle(final boolean testWhileIdle) {
assertInitializationAllowed();
this.defaultTestWhileIdle = testWhileIdle;
}
/**
* Sets the default value for {@link GenericObjectPool#getDurationBetweenEvictionRuns()} for each per user pool.
*
* @param timeBetweenEvictionRunsMillis The default value for
* {@link GenericObjectPool#getDurationBetweenEvictionRuns()} for each per user pool.
* @deprecated Use {@link #setDefaultDurationBetweenEvictionRuns(Duration)}.
*/
@Deprecated
public void setDefaultTimeBetweenEvictionRunsMillis(final long timeBetweenEvictionRunsMillis) {
assertInitializationAllowed();
this.defaultDurationBetweenEvictionRuns = Duration.ofMillis(timeBetweenEvictionRunsMillis);
}
/**
* Sets the value of defaultTransactionIsolation, which defines the state of connections handed out from this pool.
* The value can be changed on the Connection using Connection.setTransactionIsolation(int). The default is JDBC
* driver dependent.
*
* @param defaultTransactionIsolation
* Value to assign to defaultTransactionIsolation
*/
public void setDefaultTransactionIsolation(final int defaultTransactionIsolation) {
assertInitializationAllowed();
switch (defaultTransactionIsolation) {
case Connection.TRANSACTION_NONE:
case Connection.TRANSACTION_READ_COMMITTED:
case Connection.TRANSACTION_READ_UNCOMMITTED:
case Connection.TRANSACTION_REPEATABLE_READ:
case Connection.TRANSACTION_SERIALIZABLE:
break;
default:
throw new IllegalArgumentException(BAD_TRANSACTION_ISOLATION);
}
this.defaultTransactionIsolation = defaultTransactionIsolation;
}
/**
* Sets the description. This property is defined by JDBC as for use with GUI (or other) tools that might deploy the
* datasource. It serves no internal purpose.
*
* @param description
* Value to assign to description.
*/
public void setDescription(final String description) {
this.description = description;
}
/**
* Sets the JNDI environment to be used when instantiating a JNDI InitialContext. This InitialContext is used to
* locate the back end ConnectionPoolDataSource.
*
* @param properties
* the JNDI environment property to set which will overwrite any current settings
*/
void setJndiEnvironment(final Properties properties) {
if (jndiEnvironment == null) {
jndiEnvironment = new Properties();
} else {
jndiEnvironment.clear();
}
jndiEnvironment.putAll(properties);
}
/**
* Sets the value of the given JNDI environment property to be used when instantiating a JNDI InitialContext. This
* InitialContext is used to locate the back end ConnectionPoolDataSource.
*
* @param key
* the JNDI environment property to set.
* @param value
* the value assigned to specified JNDI environment property.
*/
public void setJndiEnvironment(final String key, final String value) {
if (jndiEnvironment == null) {
jndiEnvironment = new Properties();
}
jndiEnvironment.setProperty(key, value);
}
/**
* Sets the value of loginTimeout.
*
* @param loginTimeout
* Value to assign to loginTimeout.
* @since 2.10.0
*/
public void setLoginTimeout(final Duration loginTimeout) {
this.loginTimeoutDuration = loginTimeout;
}
/**
* Sets the value of loginTimeout.
*
* @param loginTimeout
* Value to assign to loginTimeout.
* @deprecated Use {@link #setLoginTimeout(Duration)}.
*/
@Deprecated
@Override
public void setLoginTimeout(final int loginTimeout) {
this.loginTimeoutDuration = Duration.ofSeconds(loginTimeout);
}
/**
* Sets the value of logWriter.
*
* @param logWriter
* Value to assign to logWriter.
*/
@Override
public void setLogWriter(final PrintWriter logWriter) {
this.logWriter = logWriter;
}
/**
*
* Sets the maximum permitted lifetime of a connection. 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.
*
*
* @param maxConnLifetimeMillis
* The maximum permitted lifetime of a connection. A value of zero or less indicates an
* infinite lifetime.
* @since 2.9.0
*/
public void setMaxConnLifetime(final Duration maxConnLifetimeMillis) {
this.maxConnDuration = 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.
*
*
* @param maxConnLifetimeMillis
* The maximum permitted lifetime of a connection in milliseconds. A value of zero or less indicates an
* infinite lifetime.
* @deprecated Use {@link #setMaxConnLifetime(Duration)}.
*/
@Deprecated
public void setMaxConnLifetimeMillis(final long maxConnLifetimeMillis) {
setMaxConnLifetime(Duration.ofMillis(maxConnLifetimeMillis));
}
/**
* Whether a rollback will be issued after executing the SQL query that will be used to validate connections from
* this pool before returning them to the caller. Default behavior is NOT to issue a rollback. The setting will only
* have an effect if a validation query is set
*
* @param rollbackAfterValidation
* new property value
*/
public void setRollbackAfterValidation(final boolean rollbackAfterValidation) {
assertInitializationAllowed();
this.rollbackAfterValidation = rollbackAfterValidation;
}
protected abstract void setupDefaults(Connection connection, String userName) throws SQLException;
/**
* Sets 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, connections will be validated using {@link Connection#isValid(int)}.
*
* @param validationQuery
* The SQL query that will be used to validate connections from this pool before returning them to the
* caller.
*/
public void setValidationQuery(final String validationQuery) {
assertInitializationAllowed();
this.validationQuery = validationQuery;
}
/**
* Sets the timeout duration before the validation query fails.
*
* @param validationQueryTimeoutDuration
* The new timeout duration.
*/
public void setValidationQueryTimeout(final Duration validationQueryTimeoutDuration) {
this.validationQueryTimeoutDuration = validationQueryTimeoutDuration;
}
/**
* Sets the timeout in seconds before the validation query fails.
*
* @param validationQueryTimeoutSeconds
* The new timeout in seconds
* @deprecated Use {@link #setValidationQueryTimeout(Duration)}.
*/
@Deprecated
public void setValidationQueryTimeout(final int validationQueryTimeoutSeconds) {
this.validationQueryTimeoutDuration = Duration.ofSeconds(validationQueryTimeoutSeconds);
}
protected ConnectionPoolDataSource testCPDS(final String userName, final String userPassword)
throws javax.naming.NamingException, SQLException {
// The source of physical db connections
ConnectionPoolDataSource cpds = this.dataSource;
if (cpds == null) {
Context ctx = null;
if (jndiEnvironment == null) {
ctx = new InitialContext();
} else {
ctx = new InitialContext(jndiEnvironment);
}
final Object ds = ctx.lookup(dataSourceName);
if (!(ds instanceof ConnectionPoolDataSource)) {
throw new SQLException("Illegal configuration: " + "DataSource " + dataSourceName + " ("
+ ds.getClass().getName() + ")" + " doesn't implement javax.sql.ConnectionPoolDataSource");
}
cpds = (ConnectionPoolDataSource) ds;
}
// try to get a connection with the supplied userName/password
PooledConnection conn = null;
try {
if (userName != null) {
conn = cpds.getPooledConnection(userName, userPassword);
} else {
conn = cpds.getPooledConnection();
}
if (conn == null) {
throw new SQLException("Cannot connect using the supplied userName/password");
}
} finally {
if (conn != null) {
try {
conn.close();
} catch (final SQLException ignored) {
// at least we could connect
}
}
}
return cpds;
}
/**
* @since 2.6.0
*/
@Override
public synchronized String toString() {
final StringBuilder builder = new StringBuilder(super.toString());
builder.append('[');
toStringFields(builder);
builder.append(']');
return builder.toString();
}
protected void toStringFields(final StringBuilder builder) {
builder.append("getConnectionCalled=");
builder.append(getConnectionCalled);
builder.append(", dataSource=");
builder.append(dataSource);
builder.append(", dataSourceName=");
builder.append(dataSourceName);
builder.append(", description=");
builder.append(description);
builder.append(", jndiEnvironment=");
builder.append(jndiEnvironment);
builder.append(", loginTimeoutDuration=");
builder.append(loginTimeoutDuration);
builder.append(", logWriter=");
builder.append(logWriter);
builder.append(", instanceKey=");
builder.append(instanceKey);
builder.append(", defaultBlockWhenExhausted=");
builder.append(defaultBlockWhenExhausted);
builder.append(", defaultEvictionPolicyClassName=");
builder.append(defaultEvictionPolicyClassName);
builder.append(", defaultLifo=");
builder.append(defaultLifo);
builder.append(", defaultMaxIdle=");
builder.append(defaultMaxIdle);
builder.append(", defaultMaxTotal=");
builder.append(defaultMaxTotal);
builder.append(", defaultMaxWaitDuration=");
builder.append(defaultMaxWaitDuration);
builder.append(", defaultMinEvictableIdleDuration=");
builder.append(defaultMinEvictableIdleDuration);
builder.append(", defaultMinIdle=");
builder.append(defaultMinIdle);
builder.append(", defaultNumTestsPerEvictionRun=");
builder.append(defaultNumTestsPerEvictionRun);
builder.append(", defaultSoftMinEvictableIdleDuration=");
builder.append(defaultSoftMinEvictableIdleDuration);
builder.append(", defaultTestOnCreate=");
builder.append(defaultTestOnCreate);
builder.append(", defaultTestOnBorrow=");
builder.append(defaultTestOnBorrow);
builder.append(", defaultTestOnReturn=");
builder.append(defaultTestOnReturn);
builder.append(", defaultTestWhileIdle=");
builder.append(defaultTestWhileIdle);
builder.append(", defaultDurationBetweenEvictionRuns=");
builder.append(defaultDurationBetweenEvictionRuns);
builder.append(", validationQuery=");
builder.append(validationQuery);
builder.append(", validationQueryTimeoutDuration=");
builder.append(validationQueryTimeoutDuration);
builder.append(", rollbackAfterValidation=");
builder.append(rollbackAfterValidation);
builder.append(", maxConnDuration=");
builder.append(maxConnDuration);
builder.append(", defaultAutoCommit=");
builder.append(defaultAutoCommit);
builder.append(", defaultTransactionIsolation=");
builder.append(defaultTransactionIsolation);
builder.append(", defaultReadOnly=");
builder.append(defaultReadOnly);
}
@Override
@SuppressWarnings("unchecked")
public T unwrap(final Class iface) throws SQLException {
if (isWrapperFor(iface)) {
return (T) this;
}
throw new SQLException(this + " is not a wrapper for " + iface);
}
}
InstanceKeyDataSourceFactory.java 0000664 0000000 0000000 00000032207 14473117325 0037257 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/datasources /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.datasources;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.RefAddr;
import javax.naming.Reference;
import javax.naming.spi.ObjectFactory;
import org.apache.commons.dbcp2.ListException;
import org.apache.commons.dbcp2.Utils;
/**
* A JNDI ObjectFactory which creates {@code SharedPoolDataSource}s or {@code PerUserPoolDataSource}s
*
* @since 2.0
*/
abstract class InstanceKeyDataSourceFactory implements ObjectFactory {
private static final Map INSTANCE_MAP = new ConcurrentHashMap<>();
/**
* Closes all pools associated with this class.
*
* @throws ListException
* a {@link ListException} containing all exceptions thrown by {@link InstanceKeyDataSource#close()}
* @see InstanceKeyDataSource#close()
* @since 2.4.0 throws a {@link ListException} instead of, in 2.3.0 and before, the first exception thrown by
* {@link InstanceKeyDataSource#close()}.
*/
public static void closeAll() throws ListException {
// Get iterator to loop over all instances of this data source.
final List exceptionList = new ArrayList<>(INSTANCE_MAP.size());
INSTANCE_MAP.entrySet().forEach(entry -> {
// Bullet-proof to avoid anything else but problems from InstanceKeyDataSource#close().
if (entry != null) {
@SuppressWarnings("resource")
final InstanceKeyDataSource value = entry.getValue();
Utils.close(value, exceptionList::add);
}
});
INSTANCE_MAP.clear();
if (!exceptionList.isEmpty()) {
throw new ListException("Could not close all InstanceKeyDataSource instances.", exceptionList);
}
}
/**
* Deserializes the provided byte array to create an object.
*
* @param data
* Data to deserialize to create the configuration parameter.
*
* @return The Object created by deserializing the data.
*
* @throws ClassNotFoundException
* If a class cannot be found during the deserialization of a configuration parameter.
* @throws IOException
* If an I/O error occurs during the deserialization of a configuration parameter.
*/
protected static final Object deserialize(final byte[] data) throws IOException, ClassNotFoundException {
ObjectInputStream in = null;
try {
in = new ObjectInputStream(new ByteArrayInputStream(data));
return in.readObject();
} finally {
Utils.closeQuietly(in);
}
}
static synchronized String registerNewInstance(final InstanceKeyDataSource ds) {
int max = 0;
for (final String s : INSTANCE_MAP.keySet()) {
if (s != null) {
try {
max = Math.max(max, Integer.parseInt(s));
} catch (final NumberFormatException ignored) {
// no sweat, ignore those keys
}
}
}
final String instanceKey = String.valueOf(max + 1);
// Put a placeholder here for now, so other instances will not
// take our key. We will replace with a pool when ready.
INSTANCE_MAP.put(instanceKey, ds);
return instanceKey;
}
static void removeInstance(final String key) {
if (key != null) {
INSTANCE_MAP.remove(key);
}
}
/**
* Creates an instance of the subclass and sets any properties contained in the Reference.
*
* @param ref
* The properties to be set on the created DataSource
*
* @return A configured DataSource of the appropriate type.
*
* @throws ClassNotFoundException
* If a class cannot be found during the deserialization of a configuration parameter.
* @throws IOException
* If an I/O error occurs during the deserialization of a configuration parameter.
*/
protected abstract InstanceKeyDataSource getNewInstance(Reference ref) throws IOException, ClassNotFoundException;
/**
* Implements ObjectFactory to create an instance of SharedPoolDataSource or PerUserPoolDataSource
*/
@Override
public Object getObjectInstance(final Object refObj, final Name name, final Context context,
final Hashtable env) throws IOException, ClassNotFoundException {
// The spec says to return null if we can't create an instance
// of the reference
Object obj = null;
if (refObj instanceof Reference) {
final Reference ref = (Reference) refObj;
if (isCorrectClass(ref.getClassName())) {
final RefAddr refAddr = ref.get("instanceKey");
if (refAddr != null && refAddr.getContent() != null) {
// object was bound to JNDI via Referenceable API.
obj = INSTANCE_MAP.get(refAddr.getContent());
} else {
// Tomcat JNDI creates a Reference out of server.xml
// configuration and passes it to an
// instance of the factory given in server.xml.
String key = null;
if (name != null) {
key = name.toString();
obj = INSTANCE_MAP.get(key);
}
if (obj == null) {
final InstanceKeyDataSource ds = getNewInstance(ref);
setCommonProperties(ref, ds);
obj = ds;
if (key != null) {
INSTANCE_MAP.put(key, ds);
}
}
}
}
}
return obj;
}
/**
* Tests if className is the value returned from getClass().getName().toString().
*
* @param className
* The class name to test.
*
* @return true if and only if className is the value returned from getClass().getName().toString()
*/
protected abstract boolean isCorrectClass(String className);
boolean parseBoolean(final RefAddr refAddr) {
return Boolean.parseBoolean(toString(refAddr));
}
int parseInt(final RefAddr refAddr) {
return Integer.parseInt(toString(refAddr));
}
long parseLong(final RefAddr refAddr) {
return Long.parseLong(toString(refAddr));
}
private void setCommonProperties(final Reference ref, final InstanceKeyDataSource ikds)
throws IOException, ClassNotFoundException {
RefAddr refAddr = ref.get("dataSourceName");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDataSourceName(toString(refAddr));
}
refAddr = ref.get("description");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDescription(toString(refAddr));
}
refAddr = ref.get("jndiEnvironment");
if (refAddr != null && refAddr.getContent() != null) {
final byte[] serialized = (byte[]) refAddr.getContent();
ikds.setJndiEnvironment((Properties) deserialize(serialized));
}
refAddr = ref.get("loginTimeout");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setLoginTimeout(Duration.ofSeconds(parseInt(refAddr)));
}
// Pool properties
refAddr = ref.get("blockWhenExhausted");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultBlockWhenExhausted(parseBoolean(refAddr));
}
refAddr = ref.get("evictionPolicyClassName");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultEvictionPolicyClassName(toString(refAddr));
}
// Pool properties
refAddr = ref.get("lifo");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultLifo(parseBoolean(refAddr));
}
refAddr = ref.get("maxIdlePerKey");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultMaxIdle(parseInt(refAddr));
}
refAddr = ref.get("maxTotalPerKey");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultMaxTotal(parseInt(refAddr));
}
refAddr = ref.get("maxWaitMillis");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultMaxWait(Duration.ofMillis(parseLong(refAddr)));
}
refAddr = ref.get("minEvictableIdleTimeMillis");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultMinEvictableIdle(Duration.ofMillis(parseLong(refAddr)));
}
refAddr = ref.get("minIdlePerKey");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultMinIdle(parseInt(refAddr));
}
refAddr = ref.get("numTestsPerEvictionRun");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultNumTestsPerEvictionRun(parseInt(refAddr));
}
refAddr = ref.get("softMinEvictableIdleTimeMillis");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultSoftMinEvictableIdle(Duration.ofMillis(parseLong(refAddr)));
}
refAddr = ref.get("testOnCreate");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultTestOnCreate(parseBoolean(refAddr));
}
refAddr = ref.get("testOnBorrow");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultTestOnBorrow(parseBoolean(refAddr));
}
refAddr = ref.get("testOnReturn");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultTestOnReturn(parseBoolean(refAddr));
}
refAddr = ref.get("testWhileIdle");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultTestWhileIdle(parseBoolean(refAddr));
}
refAddr = ref.get("timeBetweenEvictionRunsMillis");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultDurationBetweenEvictionRuns(Duration.ofMillis(parseLong(refAddr)));
}
// Connection factory properties
refAddr = ref.get("validationQuery");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setValidationQuery(toString(refAddr));
}
refAddr = ref.get("validationQueryTimeout");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setValidationQueryTimeout(Duration.ofSeconds(parseInt(refAddr)));
}
refAddr = ref.get("rollbackAfterValidation");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setRollbackAfterValidation(parseBoolean(refAddr));
}
refAddr = ref.get("maxConnLifetimeMillis");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setMaxConnLifetime(Duration.ofMillis(parseLong(refAddr)));
}
// Connection properties
refAddr = ref.get("defaultAutoCommit");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultAutoCommit(Boolean.valueOf(toString(refAddr)));
}
refAddr = ref.get("defaultTransactionIsolation");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultTransactionIsolation(parseInt(refAddr));
}
refAddr = ref.get("defaultReadOnly");
if (refAddr != null && refAddr.getContent() != null) {
ikds.setDefaultReadOnly(Boolean.valueOf(toString(refAddr)));
}
}
String toString(final RefAddr refAddr) {
return refAddr.getContent().toString();
}
}
KeyedCPDSConnectionFactory.java 0000664 0000000 0000000 00000037773 14473117325 0036637 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/datasources /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.datasources;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.Duration;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.sql.ConnectionEvent;
import javax.sql.ConnectionEventListener;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import org.apache.commons.dbcp2.Utils;
import org.apache.commons.pool2.KeyedObjectPool;
import org.apache.commons.pool2.KeyedPooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
/**
* A {@link KeyedPooledObjectFactory} that creates {@link org.apache.commons.dbcp2.PoolableConnection
* PoolableConnection}s.
*
* @since 2.0
*/
final class KeyedCPDSConnectionFactory implements KeyedPooledObjectFactory,
ConnectionEventListener, PooledConnectionManager {
private static final String NO_KEY_MESSAGE = "close() was called on a Connection, but "
+ "I have no record of the underlying PooledConnection.";
private final ConnectionPoolDataSource cpds;
private final String validationQuery;
private final Duration validationQueryTimeoutDuration;
private final boolean rollbackAfterValidation;
private KeyedObjectPool pool;
private Duration maxConnLifetime = Duration.ofMillis(-1);
/**
* Map of PooledConnections for which close events are ignored. Connections are muted when they are being validated.
*/
private final Set validatingSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
/**
* Map of PooledConnectionAndInfo instances
*/
private final Map pcMap = new ConcurrentHashMap<>();
/**
* Creates a new {@code KeyedPoolableConnectionFactory}.
*
* @param cpds
* the ConnectionPoolDataSource from which to obtain PooledConnections
* @param validationQuery
* a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one
* row. May be {@code null} in which case3 {@link Connection#isValid(int)} will be used to validate
* connections.
* @param validationQueryTimeoutSeconds
* The Duration to allow for the validation query to complete
* @param rollbackAfterValidation
* whether a rollback should be issued after {@link #validateObject validating} {@link Connection}s.
* @since 2.10.0
*/
public KeyedCPDSConnectionFactory(final ConnectionPoolDataSource cpds, final String validationQuery,
final Duration validationQueryTimeoutSeconds, final boolean rollbackAfterValidation) {
this.cpds = cpds;
this.validationQuery = validationQuery;
this.validationQueryTimeoutDuration = validationQueryTimeoutSeconds;
this.rollbackAfterValidation = rollbackAfterValidation;
}
/**
* Creates a new {@code KeyedPoolableConnectionFactory}.
*
* @param cpds
* the ConnectionPoolDataSource from which to obtain PooledConnections
* @param validationQuery
* a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one
* row. May be {@code null} in which case3 {@link Connection#isValid(int)} will be used to validate
* connections.
* @param validationQueryTimeoutSeconds
* The time, in seconds, to allow for the validation query to complete
* @param rollbackAfterValidation
* whether a rollback should be issued after {@link #validateObject validating} {@link Connection}s.
* @deprecated Use {@link #KeyedCPDSConnectionFactory(ConnectionPoolDataSource, String, Duration, boolean)}.
*/
@Deprecated
public KeyedCPDSConnectionFactory(final ConnectionPoolDataSource cpds, final String validationQuery,
final int validationQueryTimeoutSeconds, final boolean rollbackAfterValidation) {
this(cpds, validationQuery, Duration.ofSeconds(validationQueryTimeoutSeconds), rollbackAfterValidation);
}
@Override
public void activateObject(final UserPassKey key, final PooledObject p) throws SQLException {
validateLifetime(p);
}
/**
* This implementation does not fully close the KeyedObjectPool, as this would affect all users. Instead, it clears
* the pool associated with the given user. This method is not currently used.
*/
@Override
public void closePool(final String userName) throws SQLException {
try {
pool.clear(new UserPassKey(userName));
} catch (final Exception ex) {
throw new SQLException("Error closing connection pool", ex);
}
}
/**
* This will be called if the Connection returned by the getConnection method came from a PooledConnection, and the
* user calls the close() method of this connection object. What we need to do here is to release this
* PooledConnection from our pool...
*/
@Override
public void connectionClosed(final ConnectionEvent event) {
final PooledConnection pc = (PooledConnection) event.getSource();
// if this event occurred because we were validating, or if this
// connection has been marked for removal, ignore it
// otherwise return the connection to the pool.
if (!validatingSet.contains(pc)) {
final PooledConnectionAndInfo pci = pcMap.get(pc);
if (pci == null) {
throw new IllegalStateException(NO_KEY_MESSAGE);
}
try {
pool.returnObject(pci.getUserPassKey(), pci);
} catch (final Exception e) {
System.err.println("CLOSING DOWN CONNECTION AS IT COULD " + "NOT BE RETURNED TO THE POOL");
pc.removeConnectionEventListener(this);
try {
pool.invalidateObject(pci.getUserPassKey(), pci);
} catch (final Exception e3) {
System.err.println("EXCEPTION WHILE DESTROYING OBJECT " + pci);
e3.printStackTrace();
}
}
}
}
/**
* If a fatal error occurs, close the underlying physical connection so as not to be returned in the future
*/
@Override
public void connectionErrorOccurred(final ConnectionEvent event) {
final PooledConnection pc = (PooledConnection) event.getSource();
if (null != event.getSQLException()) {
System.err.println("CLOSING DOWN CONNECTION DUE TO INTERNAL ERROR (" + event.getSQLException() + ")");
}
pc.removeConnectionEventListener(this);
final PooledConnectionAndInfo info = pcMap.get(pc);
if (info == null) {
throw new IllegalStateException(NO_KEY_MESSAGE);
}
try {
pool.invalidateObject(info.getUserPassKey(), info);
} catch (final Exception e) {
System.err.println("EXCEPTION WHILE DESTROYING OBJECT " + info);
e.printStackTrace();
}
}
/**
* Closes the PooledConnection and stops listening for events from it.
*/
@Override
public void destroyObject(final UserPassKey key, final PooledObject p) throws SQLException {
final PooledConnection pooledConnection = p.getObject().getPooledConnection();
pooledConnection.removeConnectionEventListener(this);
pcMap.remove(pooledConnection);
pooledConnection.close();
}
/**
* Returns the keyed object pool used to pool connections created by this factory.
*
* @return KeyedObjectPool managing pooled connections
*/
public KeyedObjectPool getPool() {
return pool;
}
/**
* Invalidates the PooledConnection in the pool. The KeyedCPDSConnectionFactory closes the connection and pool
* counters are updated appropriately. Also clears any idle instances associated with the user name that was used to
* create the PooledConnection. Connections associated with this user are not affected, and they will not be
* automatically closed on return to the pool.
*/
@Override
public void invalidate(final PooledConnection pc) throws SQLException {
final PooledConnectionAndInfo info = pcMap.get(pc);
if (info == null) {
throw new IllegalStateException(NO_KEY_MESSAGE);
}
final UserPassKey key = info.getUserPassKey();
try {
pool.invalidateObject(key, info); // Destroy and update pool counters
pool.clear(key); // Remove any idle instances with this key
} catch (final Exception ex) {
throw new SQLException("Error invalidating connection", ex);
}
}
/**
* Creates a new {@code PooledConnectionAndInfo} from the given {@code UserPassKey}.
*
* @param userPassKey
* {@code UserPassKey} containing user credentials
* @throws SQLException
* if the connection could not be created.
* @see org.apache.commons.pool2.KeyedPooledObjectFactory#makeObject(Object)
*/
@Override
public synchronized PooledObject makeObject(final UserPassKey userPassKey) throws SQLException {
PooledConnection pooledConnection = null;
final String userName = userPassKey.getUserName();
final String password = userPassKey.getPassword();
if (userName == null) {
pooledConnection = cpds.getPooledConnection();
} else {
pooledConnection = cpds.getPooledConnection(userName, password);
}
if (pooledConnection == null) {
throw new IllegalStateException("Connection pool data source returned null from getPooledConnection");
}
// should we add this object as a listener or the pool.
// consider the validateObject method in decision
pooledConnection.addConnectionEventListener(this);
final PooledConnectionAndInfo pci = new PooledConnectionAndInfo(pooledConnection, userPassKey);
pcMap.put(pooledConnection, pci);
return new DefaultPooledObject<>(pci);
}
@Override
public void passivateObject(final UserPassKey key, final PooledObject p) throws SQLException {
validateLifetime(p);
}
/**
* Sets the maximum lifetime of a connection after which the connection will always fail activation,
* passivation and validation.
*
* @param maxConnLifetimeMillis
* A value of zero or less indicates an infinite lifetime. The default value is -1 milliseconds.
* @since 2.10.0
*/
public void setMaxConn(final Duration maxConnLifetimeMillis) {
this.maxConnLifetime = maxConnLifetimeMillis;
}
/**
* Sets the maximum lifetime of a connection after which the connection will always fail activation,
* passivation and validation.
*
* @param maxConnLifetimeMillis
* A value of zero or less indicates an infinite lifetime. The default value is -1 milliseconds.
* @since 2.9.0
* @deprecated Use {@link #setMaxConn(Duration)}.
*/
@Deprecated
public void setMaxConnLifetime(final Duration maxConnLifetimeMillis) {
this.maxConnLifetime = maxConnLifetimeMillis;
}
/**
* Sets the maximum lifetime in milliseconds of a connection after which the connection will always fail activation,
* passivation and validation.
*
* @param maxConnLifetimeMillis
* A value of zero or less indicates an infinite lifetime. The default value is -1.
* @deprecated Use {@link #setMaxConnLifetime(Duration)}.
*/
@Deprecated
public void setMaxConnLifetimeMillis(final long maxConnLifetimeMillis) {
setMaxConn(Duration.ofMillis(maxConnLifetimeMillis));
}
/**
* Does nothing. This factory does not cache user credentials.
*/
@Override
public void setPassword(final String password) {
// Does nothing. This factory does not cache user credentials.
}
public void setPool(final KeyedObjectPool pool) {
this.pool = pool;
}
private void validateLifetime(final PooledObject pooledObject) throws SQLException {
Utils.validateLifetime(pooledObject, maxConnLifetime);
}
/**
* Validates a pooled connection.
*
* @param key
* ignored
* @param pooledObject
* wrapped {@code PooledConnectionAndInfo} containing the connection to validate
* @return true if validation succeeds
*/
@Override
public boolean validateObject(final UserPassKey key, final PooledObject pooledObject) {
try {
validateLifetime(pooledObject);
} catch (final Exception e) {
return false;
}
boolean valid = false;
final PooledConnection pooledConn = pooledObject.getObject().getPooledConnection();
Connection conn = null;
validatingSet.add(pooledConn);
if (null == validationQuery) {
Duration timeoutDuration = validationQueryTimeoutDuration;
if (timeoutDuration.isNegative()) {
timeoutDuration = Duration.ZERO;
}
try {
conn = pooledConn.getConnection();
valid = conn.isValid((int) timeoutDuration.getSeconds());
} catch (final SQLException e) {
valid = false;
} finally {
Utils.closeQuietly((AutoCloseable) conn);
validatingSet.remove(pooledConn);
}
} else {
Statement stmt = null;
ResultSet rset = null;
// logical Connection from the PooledConnection must be closed
// before another one can be requested and closing it will
// generate an event. Keep track so we know not to return
// the PooledConnection
validatingSet.add(pooledConn);
try {
conn = pooledConn.getConnection();
stmt = conn.createStatement();
rset = stmt.executeQuery(validationQuery);
valid = rset.next();
if (rollbackAfterValidation) {
conn.rollback();
}
} catch (final Exception e) {
valid = false;
} finally {
Utils.closeQuietly((AutoCloseable) rset);
Utils.closeQuietly((AutoCloseable) stmt);
Utils.closeQuietly((AutoCloseable) conn);
validatingSet.remove(pooledConn);
}
}
return valid;
}
}
PerUserPoolDataSource.java 0000664 0000000 0000000 00000127553 14473117325 0035742 0 ustar 00root root 0000000 0000000 commons-dbcp-rel-commons-dbcp-2.10.0/src/main/java/org/apache/commons/dbcp2/datasources /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.dbcp2.datasources;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.StringRefAddr;
import javax.sql.ConnectionPoolDataSource;
import org.apache.commons.dbcp2.SwallowedExceptionLogger;
import org.apache.commons.dbcp2.Utils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPool;
/**
*
* A pooling {@code DataSource} appropriate for deployment within J2EE environment. There are many configuration
* options, most of which are defined in the parent class. This datasource uses individual pools per user, and some
* properties can be set specifically for a given user, if the deployment environment can support initialization of
* mapped properties. So for example, a pool of admin or write-access Connections can be guaranteed a certain number of
* connections, separate from a maximum set for users with read-only connections.
*
*
*
* User passwords can be changed without re-initializing the datasource. When a
* {@code getConnection(userName, password)} request is processed with a password that is different from those used
* to create connections in the pool associated with {@code userName}, an attempt is made to create a new
* connection using the supplied password and if this succeeds, the existing pool is cleared and a new pool is created
* for connections using the new password.
*
*
* @since 2.0
*/
public class PerUserPoolDataSource extends InstanceKeyDataSource {
private static final long serialVersionUID = 7872747993848065028L;
private static final Log log = LogFactory.getLog(PerUserPoolDataSource.class);
private static HashMap createMap() {
// Should there be a default size different from what this ctor provides?
return new HashMap<>();
}
private Map perUserBlockWhenExhausted;
private Map perUserEvictionPolicyClassName;
private Map perUserLifo;
private Map perUserMaxIdle;
private Map perUserMaxTotal;
private Map perUserMaxWaitDuration;
private Map perUserMinEvictableIdleDuration;
private Map perUserMinIdle;
private Map perUserNumTestsPerEvictionRun;
private Map perUserSoftMinEvictableIdleDuration;
private Map perUserTestOnCreate;
private Map perUserTestOnBorrow;
private Map perUserTestOnReturn;
private Map perUserTestWhileIdle;
private Map perUserDurationBetweenEvictionRuns;
private Map perUserDefaultAutoCommit;
private Map perUserDefaultTransactionIsolation;
private Map perUserDefaultReadOnly;
/**
* Map to keep track of Pools for a given user.
*/
private transient Map managers = createMap();
/**
* Default no-arg constructor for Serialization.
*/
public PerUserPoolDataSource() {
}
/**
* Clears pool(s) maintained by this data source.
*
* @see org.apache.commons.pool2.ObjectPool#clear()
* @since 2.3.0
*/
public void clear() {
managers.values().forEach(manager -> {
try {
getCPDSConnectionFactoryPool(manager).clear();
} catch (final Exception ignored) {
// ignore and try to close others.
}
});
InstanceKeyDataSourceFactory.removeInstance(getInstanceKey());
}
/**
* Closes pool(s) maintained by this data source.
*
* @see org.apache.commons.pool2.ObjectPool#close()
*/
@Override
public void close() {
managers.values().forEach(manager -> Utils.closeQuietly(getCPDSConnectionFactoryPool(manager)));
InstanceKeyDataSourceFactory.removeInstance(getInstanceKey());
}
/**
* Converts a map with Long milliseconds values to another map with Duration values.
*/
private Map convertMap(final Map currentMap, final Map longMap) {
final Map durationMap = createMap();
longMap.forEach((k, v) -> durationMap.put(k, toDurationOrNull(v)));
if (currentMap == null) {
return durationMap;
}
currentMap.clear();
currentMap.putAll(durationMap);
return currentMap;
}
@Override
protected PooledConnectionManager getConnectionManager(final UserPassKey upKey) {
return managers.get(getPoolKey(upKey.getUserName()));
}
/**
* Gets the underlying pool but does NOT allocate it.
*
* @param manager A CPDSConnectionFactory.
* @return the underlying pool.
*/
private ObjectPool getCPDSConnectionFactoryPool(final PooledConnectionManager manager) {
return ((CPDSConnectionFactory) manager).getPool();
}
/**
* Gets the number of active connections in the default pool.
*
* @return The number of active connections in the default pool.
*/
public int getNumActive() {
return getNumActive(null);
}
/**
* Gets the number of active connections in the pool for a given user.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
@SuppressWarnings("resource")
public int getNumActive(final String userName) {
final ObjectPool pool = getPool(getPoolKey(userName));
return pool == null ? 0 : pool.getNumActive();
}
/**
* Gets the number of idle connections in the default pool.
*
* @return The number of idle connections in the default pool.
*/
public int getNumIdle() {
return getNumIdle(null);
}
/**
* Gets the number of idle connections in the pool for a given user.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
@SuppressWarnings("resource")
public int getNumIdle(final String userName) {
final ObjectPool pool = getPool(getPoolKey(userName));
return pool == null ? 0 : pool.getNumIdle();
}
/**
* Gets the user specific value for {@link GenericObjectPool#getBlockWhenExhausted()} for the specified user's pool
* or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public boolean getPerUserBlockWhenExhausted(final String userName) {
Boolean value = null;
if (perUserBlockWhenExhausted != null) {
value = perUserBlockWhenExhausted.get(userName);
}
if (value == null) {
return getDefaultBlockWhenExhausted();
}
return value;
}
/**
* Gets the user specific default value for {@link Connection#setAutoCommit(boolean)} for the specified user's pool.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public Boolean getPerUserDefaultAutoCommit(final String userName) {
Boolean value = null;
if (perUserDefaultAutoCommit != null) {
value = perUserDefaultAutoCommit.get(userName);
}
return value;
}
/**
* Gets the user specific default value for {@link Connection#setReadOnly(boolean)} for the specified user's pool.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public Boolean getPerUserDefaultReadOnly(final String userName) {
Boolean value = null;
if (perUserDefaultReadOnly != null) {
value = perUserDefaultReadOnly.get(userName);
}
return value;
}
/**
* Gets the user specific default value for {@link Connection#setTransactionIsolation(int)} for the specified user's
* pool.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public Integer getPerUserDefaultTransactionIsolation(final String userName) {
Integer value = null;
if (perUserDefaultTransactionIsolation != null) {
value = perUserDefaultTransactionIsolation.get(userName);
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getDurationBetweenEvictionRuns()} for the specified
* user's pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
* @since 2.10.0
*/
public Duration getPerUserDurationBetweenEvictionRuns(final String userName) {
Duration value = null;
if (perUserDurationBetweenEvictionRuns != null) {
value = perUserDurationBetweenEvictionRuns.get(userName);
}
if (value == null) {
return getDefaultDurationBetweenEvictionRuns();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getEvictionPolicyClassName()} for the specified user's
* pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public String getPerUserEvictionPolicyClassName(final String userName) {
String value = null;
if (perUserEvictionPolicyClassName != null) {
value = perUserEvictionPolicyClassName.get(userName);
}
if (value == null) {
return getDefaultEvictionPolicyClassName();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getLifo()} for the specified user's pool or the default
* if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public boolean getPerUserLifo(final String userName) {
Boolean value = null;
if (perUserLifo != null) {
value = perUserLifo.get(userName);
}
if (value == null) {
return getDefaultLifo();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getMaxIdle()} for the specified user's pool or the
* default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public int getPerUserMaxIdle(final String userName) {
Integer value = null;
if (perUserMaxIdle != null) {
value = perUserMaxIdle.get(userName);
}
if (value == null) {
return getDefaultMaxIdle();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getMaxTotal()} for the specified user's pool or the
* default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public int getPerUserMaxTotal(final String userName) {
Integer value = null;
if (perUserMaxTotal != null) {
value = perUserMaxTotal.get(userName);
}
if (value == null) {
return getDefaultMaxTotal();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getMaxWaitDuration()} for the specified user's pool or
* the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
* @since 2.10.0
*/
public Duration getPerUserMaxWaitDuration(final String userName) {
Duration value = null;
if (perUserMaxWaitDuration != null) {
value = perUserMaxWaitDuration.get(userName);
}
if (value == null) {
return getDefaultMaxWait();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getMaxWaitDuration()} for the specified user's pool or
* the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
* @deprecated Use {@link #getPerUserMaxWaitDuration}.
*/
@Deprecated
public long getPerUserMaxWaitMillis(final String userName) {
return getPerUserMaxWaitDuration(userName).toMillis();
}
/**
* Gets the user specific value for {@link GenericObjectPool#getMinEvictableIdleDuration()} for the specified
* user's pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value, never null.
* @since 2.10.0
*/
public Duration getPerUserMinEvictableIdleDuration(final String userName) {
Duration value = null;
if (perUserMinEvictableIdleDuration != null) {
value = perUserMinEvictableIdleDuration.get(userName);
}
if (value == null) {
return getDefaultMinEvictableIdleDuration();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getMinEvictableIdleDuration()} for the specified
* user's pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
* @deprecated Use {@link #getPerUserMinEvictableIdleDuration(String)}.
*/
@Deprecated
public long getPerUserMinEvictableIdleTimeMillis(final String userName) {
return getPerUserMinEvictableIdleDuration(userName).toMillis();
}
/**
* Gets the user specific value for {@link GenericObjectPool#getMinIdle()} for the specified user's pool or the
* default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public int getPerUserMinIdle(final String userName) {
Integer value = null;
if (perUserMinIdle != null) {
value = perUserMinIdle.get(userName);
}
if (value == null) {
return getDefaultMinIdle();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getNumTestsPerEvictionRun()} for the specified user's
* pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public int getPerUserNumTestsPerEvictionRun(final String userName) {
Integer value = null;
if (perUserNumTestsPerEvictionRun != null) {
value = perUserNumTestsPerEvictionRun.get(userName);
}
if (value == null) {
return getDefaultNumTestsPerEvictionRun();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getSoftMinEvictableIdleDuration()} for the specified
* user's pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
* @since 2.10.0
*/
public Duration getPerUserSoftMinEvictableIdleDuration(final String userName) {
Duration value = null;
if (perUserSoftMinEvictableIdleDuration != null) {
value = perUserSoftMinEvictableIdleDuration.get(userName);
}
if (value == null) {
return getDefaultSoftMinEvictableIdleDuration();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getSoftMinEvictableIdleDuration()} for the specified
* user's pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
* @deprecated Use {@link #getPerUserSoftMinEvictableIdleDuration(String)}.
*/
@Deprecated
public long getPerUserSoftMinEvictableIdleTimeMillis(final String userName) {
return getPerUserSoftMinEvictableIdleDuration(userName).toMillis();
}
/**
* Gets the user specific value for {@link GenericObjectPool#getTestOnBorrow()} for the specified user's pool or the
* default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public boolean getPerUserTestOnBorrow(final String userName) {
Boolean value = null;
if (perUserTestOnBorrow != null) {
value = perUserTestOnBorrow.get(userName);
}
if (value == null) {
return getDefaultTestOnBorrow();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getTestOnCreate()} for the specified user's pool or the
* default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public boolean getPerUserTestOnCreate(final String userName) {
Boolean value = null;
if (perUserTestOnCreate != null) {
value = perUserTestOnCreate.get(userName);
}
if (value == null) {
return getDefaultTestOnCreate();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getTestOnReturn()} for the specified user's pool or the
* default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public boolean getPerUserTestOnReturn(final String userName) {
Boolean value = null;
if (perUserTestOnReturn != null) {
value = perUserTestOnReturn.get(userName);
}
if (value == null) {
return getDefaultTestOnReturn();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getTestWhileIdle()} for the specified user's pool or
* the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
*/
public boolean getPerUserTestWhileIdle(final String userName) {
Boolean value = null;
if (perUserTestWhileIdle != null) {
value = perUserTestWhileIdle.get(userName);
}
if (value == null) {
return getDefaultTestWhileIdle();
}
return value;
}
/**
* Gets the user specific value for {@link GenericObjectPool#getDurationBetweenEvictionRuns()} for the specified
* user's pool or the default if no user specific value is defined.
*
* @param userName
* The user name key.
* @return The user specific value.
* @deprecated Use {@link #getPerUserDurationBetweenEvictionRuns(String)}.
*/
@Deprecated
public long getPerUserTimeBetweenEvictionRunsMillis(final String userName) {
return getPerUserDurationBetweenEvictionRuns(userName).toMillis();
}
/**
* Returns the object pool associated with the given PoolKey.
*
* @param poolKey
* PoolKey identifying the pool
* @return the GenericObjectPool pooling connections for the userName and datasource specified by the PoolKey
*/
private ObjectPool getPool(final PoolKey poolKey) {
final CPDSConnectionFactory mgr = (CPDSConnectionFactory) managers.get(poolKey);
return mgr == null ? null : mgr.getPool();
}
@Override
protected PooledConnectionAndInfo getPooledConnectionAndInfo(final String userName, final String password)
throws SQLException {
final PoolKey key = getPoolKey(userName);
ObjectPool pool;
PooledConnectionManager manager;
synchronized (this) {
manager = managers.get(key);
if (manager == null) {
try {
registerPool(userName, password);
manager = managers.get(key);
} catch (final NamingException e) {
throw new SQLException("RegisterPool failed", e);
}
}
pool = getCPDSConnectionFactoryPool(manager);
}
PooledConnectionAndInfo info = null;
try {
info = pool.borrowObject();
} catch (final NoSuchElementException ex) {
throw new SQLException("Could not retrieve connection info from pool", ex);
} catch (final Exception e) {
// See if failure is due to CPDSConnectionFactory authentication failure
try {
testCPDS(userName, password);
} catch (final Exception ex) {
throw new SQLException("Could not retrieve connection info from pool", ex);
}
// New password works, so kill the old pool, create a new one, and borrow
manager.closePool(userName);
synchronized (this) {
managers.remove(key);
}
try {
registerPool(userName, password);
pool = getPool(key);
} catch (final NamingException ne) {
throw new SQLException("RegisterPool failed", ne);
}
try {
info = pool.borrowObject();
} catch (final Exception ex) {
throw new SQLException("Could not retrieve connection info from pool", ex);
}
}
return info;
}
/**
* Creates a pool key from the provided parameters.
*
* @param userName
* User name
* @return The pool key
*/
private PoolKey getPoolKey(final String userName) {
return new PoolKey(getDataSourceName(), userName);
}
/**
* Returns a {@code PerUserPoolDataSource} {@link Reference}.
*/
@Override
public Reference getReference() throws NamingException {
final Reference ref = new Reference(getClass().getName(), PerUserPoolDataSourceFactory.class.getName(), null);
ref.add(new StringRefAddr("instanceKey", getInstanceKey()));
return ref;
}
Map put(Map