001: /**********************************************************************************
002: * $URL: https://source.sakaiproject.org/svn/db/tags/sakai_2-4-1/db-impl/ext/src/java/org/apache/commons/dbcp/SakaiPoolableConnectionFactory.java $
003: * $Id: SakaiPoolableConnectionFactory.java 7229 2006-03-29 19:38:13Z ggolden@umich.edu $
004: ***********************************************************************************
005: *
006: * Copyright (c) 2005, 2006 The Sakai Foundation.
007: *
008: * Licensed under the Educational Community License, Version 1.0 (the "License");
009: * you may not use this file except in compliance with the License.
010: * You may obtain a copy of the License at
011: *
012: * http://www.opensource.org/licenses/ecl1.php
013: *
014: * Unless required by applicable law or agreed to in writing, software
015: * distributed under the License is distributed on an "AS IS" BASIS,
016: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: * See the License for the specific language governing permissions and
018: * limitations under the License.
019: *
020: **********************************************************************************/package org.apache.commons.dbcp;
021:
022: import java.sql.Connection;
023:
024: import org.apache.commons.pool.KeyedObjectPool;
025: import org.apache.commons.pool.KeyedObjectPoolFactory;
026: import org.apache.commons.pool.ObjectPool;
027:
028: /**
029: * <p>
030: * SakaiBasicDataSource extends apache common's BasicDataSource ...
031: * </p>
032: * <p>
033: * Based on apache commons dbcp version 1.2.1, apache commons pool version 1.2
034: * </p>
035: */
036: public class SakaiPoolableConnectionFactory extends
037: PoolableConnectionFactory {
038: /** Configuration: to rollback each connection when borrowed from the pool. */
039: protected boolean m_rollbackOnReturn = false;
040:
041: /**
042: * Create a new <tt>PoolableConnectionFactory</tt>.
043: *
044: * @param connFactory
045: * the {@link ConnectionFactory} from which to obtain base {@link Connection}s
046: * @param pool
047: * the {@link ObjectPool} in which to pool those {@link Connection}s
048: * @param stmtPoolFactory
049: * the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
050: * @param validationQuery
051: * a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
052: * @param defaultReadOnly
053: * the default "read only" setting for borrowed {@link Connection}s
054: * @param defaultAutoCommit
055: * the default "auto commit" setting for returned {@link Connection}s
056: * @param rollbackOnReturn
057: * The rollback on borrow setting
058: */
059: public SakaiPoolableConnectionFactory(
060: ConnectionFactory connFactory, ObjectPool pool,
061: KeyedObjectPoolFactory stmtPoolFactory,
062: String validationQuery, boolean defaultReadOnly,
063: boolean defaultAutoCommit, boolean rollbackOnReturn) {
064: super (connFactory, pool, stmtPoolFactory, validationQuery,
065: defaultReadOnly, defaultAutoCommit);
066: m_rollbackOnReturn = rollbackOnReturn;
067: }
068:
069: /**
070: * Create a new <tt>PoolableConnectionFactory</tt>.
071: *
072: * @param connFactory
073: * the {@link ConnectionFactory} from which to obtain base {@link Connection}s
074: * @param pool
075: * the {@link ObjectPool} in which to pool those {@link Connection}s
076: * @param stmtPoolFactory
077: * the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
078: * @param validationQuery
079: * a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
080: * @param defaultReadOnly
081: * the default "read only" setting for borrowed {@link Connection}s
082: * @param defaultAutoCommit
083: * the default "auto commit" setting for returned {@link Connection}s
084: * @param defaultTransactionIsolation
085: * the default "Transaction Isolation" setting for returned {@link Connection}s
086: * @param rollbackOnReturn
087: * The rollback on borrow setting
088: */
089: public SakaiPoolableConnectionFactory(
090: ConnectionFactory connFactory, ObjectPool pool,
091: KeyedObjectPoolFactory stmtPoolFactory,
092: String validationQuery, boolean defaultReadOnly,
093: boolean defaultAutoCommit, int defaultTransactionIsolation,
094: boolean rollbackOnReturn) {
095: super (connFactory, pool, stmtPoolFactory, validationQuery,
096: defaultReadOnly, defaultAutoCommit,
097: defaultTransactionIsolation);
098: m_rollbackOnReturn = rollbackOnReturn;
099: }
100:
101: /**
102: * Create a new <tt>PoolableConnectionFactory</tt>.
103: *
104: * @param connFactory
105: * the {@link ConnectionFactory} from which to obtain base {@link Connection}s
106: * @param pool
107: * the {@link ObjectPool} in which to pool those {@link Connection}s
108: * @param stmtPoolFactory
109: * the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
110: * @param validationQuery
111: * a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
112: * @param defaultReadOnly
113: * the default "read only" setting for borrowed {@link Connection}s
114: * @param defaultAutoCommit
115: * the default "auto commit" setting for returned {@link Connection}s
116: * @param config
117: * the AbandonedConfig if tracing SQL objects
118: * @param rollbackOnReturn
119: * The rollback on borrow setting
120: * @deprecated AbandonedConfig is now deprecated.
121: */
122: public SakaiPoolableConnectionFactory(
123: ConnectionFactory connFactory, ObjectPool pool,
124: KeyedObjectPoolFactory stmtPoolFactory,
125: String validationQuery, boolean defaultReadOnly,
126: boolean defaultAutoCommit, AbandonedConfig config,
127: boolean rollbackOnReturn) {
128: super (connFactory, pool, stmtPoolFactory, validationQuery,
129: defaultReadOnly, defaultAutoCommit, config);
130: m_rollbackOnReturn = rollbackOnReturn;
131: }
132:
133: /**
134: * Create a new <tt>PoolableConnectionFactory</tt>.
135: *
136: * @param connFactory
137: * the {@link ConnectionFactory} from which to obtain base {@link Connection}s
138: * @param pool
139: * the {@link ObjectPool} in which to pool those {@link Connection}s
140: * @param stmtPoolFactory
141: * the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
142: * @param validationQuery
143: * a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
144: * @param defaultReadOnly
145: * the default "read only" setting for borrowed {@link Connection}s
146: * @param defaultAutoCommit
147: * the default "auto commit" setting for returned {@link Connection}s
148: * @param defaultTransactionIsolation
149: * the default "Transaction Isolation" setting for returned {@link Connection}s
150: * @param config
151: * the AbandonedConfig if tracing SQL objects
152: * @param rollbackOnReturn
153: * The rollback on borrow setting
154: * @deprecated AbandonedConfig is now deprecated.
155: */
156: public SakaiPoolableConnectionFactory(
157: ConnectionFactory connFactory, ObjectPool pool,
158: KeyedObjectPoolFactory stmtPoolFactory,
159: String validationQuery, boolean defaultReadOnly,
160: boolean defaultAutoCommit, int defaultTransactionIsolation,
161: AbandonedConfig config, boolean rollbackOnReturn) {
162: super (connFactory, pool, stmtPoolFactory, validationQuery,
163: defaultReadOnly, defaultAutoCommit,
164: defaultTransactionIsolation, config);
165: m_rollbackOnReturn = rollbackOnReturn;
166: }
167:
168: /**
169: * Create a new <tt>PoolableConnectionFactory</tt>.
170: *
171: * @param connFactory
172: * the {@link ConnectionFactory} from which to obtain base {@link Connection}s
173: * @param pool
174: * the {@link ObjectPool} in which to pool those {@link Connection}s
175: * @param stmtPoolFactory
176: * the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
177: * @param validationQuery
178: * a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
179: * @param defaultReadOnly
180: * the default "read only" setting for borrowed {@link Connection}s
181: * @param defaultAutoCommit
182: * the default "auto commit" setting for returned {@link Connection}s
183: * @param defaultTransactionIsolation
184: * the default "Transaction Isolation" setting for returned {@link Connection}s
185: * @param defaultCatalog
186: * the default "catalog" setting for returned {@link Connection}s
187: * @param config
188: * the AbandonedConfig if tracing SQL objects
189: * @param rollbackOnReturn
190: * The rollback on borrow setting
191: * @deprecated AbandonedConfig is now deprecated.
192: */
193: public SakaiPoolableConnectionFactory(
194: ConnectionFactory connFactory, ObjectPool pool,
195: KeyedObjectPoolFactory stmtPoolFactory,
196: String validationQuery, boolean defaultReadOnly,
197: boolean defaultAutoCommit, int defaultTransactionIsolation,
198: String defaultCatalog, AbandonedConfig config,
199: boolean rollbackOnReturn) {
200: super (connFactory, pool, stmtPoolFactory, validationQuery,
201: defaultReadOnly, defaultAutoCommit,
202: defaultTransactionIsolation, defaultCatalog, config);
203: m_rollbackOnReturn = rollbackOnReturn;
204: }
205:
206: /**
207: * Create a new <tt>PoolableConnectionFactory</tt>.
208: *
209: * @param connFactory
210: * the {@link ConnectionFactory} from which to obtain base {@link Connection}s
211: * @param pool
212: * the {@link ObjectPool} in which to pool those {@link Connection}s
213: * @param stmtPoolFactory
214: * the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
215: * @param validationQuery
216: * a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
217: * @param defaultReadOnly
218: * the default "read only" setting for borrowed {@link Connection}s
219: * @param defaultAutoCommit
220: * the default "auto commit" setting for returned {@link Connection}s
221: * @param defaultTransactionIsolation
222: * the default "Transaction Isolation" setting for returned {@link Connection}s
223: * @param defaultCatalog
224: * the default "catalog" setting for returned {@link Connection}s
225: * @param config
226: * the AbandonedConfig if tracing SQL objects
227: * @param rollbackOnReturn
228: * The rollback on borrow setting
229: */
230: public SakaiPoolableConnectionFactory(
231: ConnectionFactory connFactory, ObjectPool pool,
232: KeyedObjectPoolFactory stmtPoolFactory,
233: String validationQuery, Boolean defaultReadOnly,
234: boolean defaultAutoCommit, int defaultTransactionIsolation,
235: String defaultCatalog, AbandonedConfig config,
236: boolean rollbackOnReturn) {
237: super (connFactory, pool, stmtPoolFactory, validationQuery,
238: defaultReadOnly, defaultAutoCommit,
239: defaultTransactionIsolation, defaultCatalog, config);
240: m_rollbackOnReturn = rollbackOnReturn;
241: }
242:
243: /**
244: * Sakai modification: don't set autocommit, don't rollback if so configured!
245: */
246: public void passivateObject(Object obj) throws Exception {
247: if (obj instanceof Connection) {
248: Connection conn = (Connection) obj;
249: if (m_rollbackOnReturn) {
250: if (!conn.getAutoCommit() && !conn.isReadOnly()) {
251: conn.rollback();
252: }
253: }
254:
255: conn.clearWarnings();
256: // conn.setAutoCommit(true);
257: }
258: if (obj instanceof DelegatingConnection) {
259: ((DelegatingConnection) obj).passivate();
260: }
261: }
262:
263: /**
264: * Sakai modifications: set auto-commit only if it does not match the default setting
265: */
266: public void activateObject(Object obj) throws Exception {
267: if (obj instanceof DelegatingConnection) {
268: ((DelegatingConnection) obj).activate();
269: }
270: if (obj instanceof Connection) {
271: Connection conn = (Connection) obj;
272: if (conn.getAutoCommit() != _defaultAutoCommit) {
273: conn.setAutoCommit(_defaultAutoCommit);
274: }
275: if ((_defaultTransactionIsolation != UNKNOWN_TRANSACTIONISOLATION)
276: && (conn.getTransactionIsolation() != _defaultTransactionIsolation)) {
277: conn
278: .setTransactionIsolation(_defaultTransactionIsolation);
279: }
280: if ((_defaultReadOnly != null)
281: && (conn.isReadOnly() != _defaultReadOnly
282: .booleanValue())) {
283: conn.setReadOnly(_defaultReadOnly.booleanValue());
284: }
285: if ((_defaultCatalog != null)
286: && (conn.getCatalog() != _defaultCatalog)) {
287: conn.setCatalog(_defaultCatalog);
288: }
289: }
290: }
291: }
|