001: /*
002: * Distributed as part of c3p0 v.0.9.1.2
003: *
004: * Copyright (C) 2005 Machinery For Change, Inc.
005: *
006: * Author: Steve Waldman <swaldman@mchange.com>
007: *
008: * This library is free software; you can redistribute it and/or modify
009: * it under the terms of the GNU Lesser General Public License version 2.1, as
010: * published by the Free Software Foundation.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
015: * GNU Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public License
018: * along with this software; see the file LICENSE. If not, write to the
019: * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
020: * Boston, MA 02111-1307, USA.
021: */
022:
023: package com.mchange.v2.sql.filter;
024:
025: import java.io.InputStream;
026: import java.io.Reader;
027: import java.lang.Object;
028: import java.lang.String;
029: import java.math.BigDecimal;
030: import java.net.URL;
031: import java.sql.Array;
032: import java.sql.Blob;
033: import java.sql.CallableStatement;
034: import java.sql.Clob;
035: import java.sql.Connection;
036: import java.sql.Date;
037: import java.sql.ParameterMetaData;
038: import java.sql.Ref;
039: import java.sql.ResultSet;
040: import java.sql.ResultSetMetaData;
041: import java.sql.SQLException;
042: import java.sql.SQLWarning;
043: import java.sql.Time;
044: import java.sql.Timestamp;
045: import java.util.Calendar;
046: import java.util.Map;
047:
048: public abstract class SynchronizedFilterCallableStatement implements
049: CallableStatement {
050: protected CallableStatement inner;
051:
052: public SynchronizedFilterCallableStatement(CallableStatement inner) {
053: this .inner = inner;
054: }
055:
056: public SynchronizedFilterCallableStatement() {
057: }
058:
059: public synchronized void setInner(CallableStatement inner) {
060: this .inner = inner;
061: }
062:
063: public synchronized CallableStatement getInner() {
064: return inner;
065: }
066:
067: public synchronized boolean wasNull() throws SQLException {
068: return inner.wasNull();
069: }
070:
071: public synchronized BigDecimal getBigDecimal(int a, int b)
072: throws SQLException {
073: return inner.getBigDecimal(a, b);
074: }
075:
076: public synchronized BigDecimal getBigDecimal(int a)
077: throws SQLException {
078: return inner.getBigDecimal(a);
079: }
080:
081: public synchronized BigDecimal getBigDecimal(String a)
082: throws SQLException {
083: return inner.getBigDecimal(a);
084: }
085:
086: public synchronized Timestamp getTimestamp(String a)
087: throws SQLException {
088: return inner.getTimestamp(a);
089: }
090:
091: public synchronized Timestamp getTimestamp(String a, Calendar b)
092: throws SQLException {
093: return inner.getTimestamp(a, b);
094: }
095:
096: public synchronized Timestamp getTimestamp(int a, Calendar b)
097: throws SQLException {
098: return inner.getTimestamp(a, b);
099: }
100:
101: public synchronized Timestamp getTimestamp(int a)
102: throws SQLException {
103: return inner.getTimestamp(a);
104: }
105:
106: public synchronized Blob getBlob(String a) throws SQLException {
107: return inner.getBlob(a);
108: }
109:
110: public synchronized Blob getBlob(int a) throws SQLException {
111: return inner.getBlob(a);
112: }
113:
114: public synchronized Clob getClob(String a) throws SQLException {
115: return inner.getClob(a);
116: }
117:
118: public synchronized Clob getClob(int a) throws SQLException {
119: return inner.getClob(a);
120: }
121:
122: public synchronized void setNull(String a, int b, String c)
123: throws SQLException {
124: inner.setNull(a, b, c);
125: }
126:
127: public synchronized void setNull(String a, int b)
128: throws SQLException {
129: inner.setNull(a, b);
130: }
131:
132: public synchronized void setBigDecimal(String a, BigDecimal b)
133: throws SQLException {
134: inner.setBigDecimal(a, b);
135: }
136:
137: public synchronized void setBytes(String a, byte[] b)
138: throws SQLException {
139: inner.setBytes(a, b);
140: }
141:
142: public synchronized void setTimestamp(String a, Timestamp b,
143: Calendar c) throws SQLException {
144: inner.setTimestamp(a, b, c);
145: }
146:
147: public synchronized void setTimestamp(String a, Timestamp b)
148: throws SQLException {
149: inner.setTimestamp(a, b);
150: }
151:
152: public synchronized void setAsciiStream(String a, InputStream b,
153: int c) throws SQLException {
154: inner.setAsciiStream(a, b, c);
155: }
156:
157: public synchronized void setBinaryStream(String a, InputStream b,
158: int c) throws SQLException {
159: inner.setBinaryStream(a, b, c);
160: }
161:
162: public synchronized void setObject(String a, Object b)
163: throws SQLException {
164: inner.setObject(a, b);
165: }
166:
167: public synchronized void setObject(String a, Object b, int c, int d)
168: throws SQLException {
169: inner.setObject(a, b, c, d);
170: }
171:
172: public synchronized void setObject(String a, Object b, int c)
173: throws SQLException {
174: inner.setObject(a, b, c);
175: }
176:
177: public synchronized void setCharacterStream(String a, Reader b,
178: int c) throws SQLException {
179: inner.setCharacterStream(a, b, c);
180: }
181:
182: public synchronized void registerOutParameter(String a, int b)
183: throws SQLException {
184: inner.registerOutParameter(a, b);
185: }
186:
187: public synchronized void registerOutParameter(int a, int b)
188: throws SQLException {
189: inner.registerOutParameter(a, b);
190: }
191:
192: public synchronized void registerOutParameter(int a, int b, int c)
193: throws SQLException {
194: inner.registerOutParameter(a, b, c);
195: }
196:
197: public synchronized void registerOutParameter(int a, int b, String c)
198: throws SQLException {
199: inner.registerOutParameter(a, b, c);
200: }
201:
202: public synchronized void registerOutParameter(String a, int b, int c)
203: throws SQLException {
204: inner.registerOutParameter(a, b, c);
205: }
206:
207: public synchronized void registerOutParameter(String a, int b,
208: String c) throws SQLException {
209: inner.registerOutParameter(a, b, c);
210: }
211:
212: public synchronized Object getObject(String a, Map b)
213: throws SQLException {
214: return inner.getObject(a, b);
215: }
216:
217: public synchronized Object getObject(int a, Map b)
218: throws SQLException {
219: return inner.getObject(a, b);
220: }
221:
222: public synchronized Object getObject(int a) throws SQLException {
223: return inner.getObject(a);
224: }
225:
226: public synchronized Object getObject(String a) throws SQLException {
227: return inner.getObject(a);
228: }
229:
230: public synchronized boolean getBoolean(int a) throws SQLException {
231: return inner.getBoolean(a);
232: }
233:
234: public synchronized boolean getBoolean(String a)
235: throws SQLException {
236: return inner.getBoolean(a);
237: }
238:
239: public synchronized byte getByte(String a) throws SQLException {
240: return inner.getByte(a);
241: }
242:
243: public synchronized byte getByte(int a) throws SQLException {
244: return inner.getByte(a);
245: }
246:
247: public synchronized short getShort(int a) throws SQLException {
248: return inner.getShort(a);
249: }
250:
251: public synchronized short getShort(String a) throws SQLException {
252: return inner.getShort(a);
253: }
254:
255: public synchronized int getInt(String a) throws SQLException {
256: return inner.getInt(a);
257: }
258:
259: public synchronized int getInt(int a) throws SQLException {
260: return inner.getInt(a);
261: }
262:
263: public synchronized long getLong(int a) throws SQLException {
264: return inner.getLong(a);
265: }
266:
267: public synchronized long getLong(String a) throws SQLException {
268: return inner.getLong(a);
269: }
270:
271: public synchronized float getFloat(String a) throws SQLException {
272: return inner.getFloat(a);
273: }
274:
275: public synchronized float getFloat(int a) throws SQLException {
276: return inner.getFloat(a);
277: }
278:
279: public synchronized double getDouble(String a) throws SQLException {
280: return inner.getDouble(a);
281: }
282:
283: public synchronized double getDouble(int a) throws SQLException {
284: return inner.getDouble(a);
285: }
286:
287: public synchronized byte[] getBytes(int a) throws SQLException {
288: return inner.getBytes(a);
289: }
290:
291: public synchronized byte[] getBytes(String a) throws SQLException {
292: return inner.getBytes(a);
293: }
294:
295: public synchronized URL getURL(String a) throws SQLException {
296: return inner.getURL(a);
297: }
298:
299: public synchronized URL getURL(int a) throws SQLException {
300: return inner.getURL(a);
301: }
302:
303: public synchronized void setBoolean(String a, boolean b)
304: throws SQLException {
305: inner.setBoolean(a, b);
306: }
307:
308: public synchronized void setByte(String a, byte b)
309: throws SQLException {
310: inner.setByte(a, b);
311: }
312:
313: public synchronized void setShort(String a, short b)
314: throws SQLException {
315: inner.setShort(a, b);
316: }
317:
318: public synchronized void setInt(String a, int b)
319: throws SQLException {
320: inner.setInt(a, b);
321: }
322:
323: public synchronized void setLong(String a, long b)
324: throws SQLException {
325: inner.setLong(a, b);
326: }
327:
328: public synchronized void setFloat(String a, float b)
329: throws SQLException {
330: inner.setFloat(a, b);
331: }
332:
333: public synchronized void setDouble(String a, double b)
334: throws SQLException {
335: inner.setDouble(a, b);
336: }
337:
338: public synchronized String getString(String a) throws SQLException {
339: return inner.getString(a);
340: }
341:
342: public synchronized String getString(int a) throws SQLException {
343: return inner.getString(a);
344: }
345:
346: public synchronized Ref getRef(int a) throws SQLException {
347: return inner.getRef(a);
348: }
349:
350: public synchronized Ref getRef(String a) throws SQLException {
351: return inner.getRef(a);
352: }
353:
354: public synchronized void setURL(String a, URL b)
355: throws SQLException {
356: inner.setURL(a, b);
357: }
358:
359: public synchronized void setTime(String a, Time b)
360: throws SQLException {
361: inner.setTime(a, b);
362: }
363:
364: public synchronized void setTime(String a, Time b, Calendar c)
365: throws SQLException {
366: inner.setTime(a, b, c);
367: }
368:
369: public synchronized Time getTime(int a, Calendar b)
370: throws SQLException {
371: return inner.getTime(a, b);
372: }
373:
374: public synchronized Time getTime(String a) throws SQLException {
375: return inner.getTime(a);
376: }
377:
378: public synchronized Time getTime(int a) throws SQLException {
379: return inner.getTime(a);
380: }
381:
382: public synchronized Time getTime(String a, Calendar b)
383: throws SQLException {
384: return inner.getTime(a, b);
385: }
386:
387: public synchronized Date getDate(int a, Calendar b)
388: throws SQLException {
389: return inner.getDate(a, b);
390: }
391:
392: public synchronized Date getDate(String a) throws SQLException {
393: return inner.getDate(a);
394: }
395:
396: public synchronized Date getDate(int a) throws SQLException {
397: return inner.getDate(a);
398: }
399:
400: public synchronized Date getDate(String a, Calendar b)
401: throws SQLException {
402: return inner.getDate(a, b);
403: }
404:
405: public synchronized void setString(String a, String b)
406: throws SQLException {
407: inner.setString(a, b);
408: }
409:
410: public synchronized Array getArray(int a) throws SQLException {
411: return inner.getArray(a);
412: }
413:
414: public synchronized Array getArray(String a) throws SQLException {
415: return inner.getArray(a);
416: }
417:
418: public synchronized void setDate(String a, Date b, Calendar c)
419: throws SQLException {
420: inner.setDate(a, b, c);
421: }
422:
423: public synchronized void setDate(String a, Date b)
424: throws SQLException {
425: inner.setDate(a, b);
426: }
427:
428: public synchronized ResultSetMetaData getMetaData()
429: throws SQLException {
430: return inner.getMetaData();
431: }
432:
433: public synchronized ResultSet executeQuery() throws SQLException {
434: return inner.executeQuery();
435: }
436:
437: public synchronized int executeUpdate() throws SQLException {
438: return inner.executeUpdate();
439: }
440:
441: public synchronized void addBatch() throws SQLException {
442: inner.addBatch();
443: }
444:
445: public synchronized void setNull(int a, int b, String c)
446: throws SQLException {
447: inner.setNull(a, b, c);
448: }
449:
450: public synchronized void setNull(int a, int b) throws SQLException {
451: inner.setNull(a, b);
452: }
453:
454: public synchronized void setBigDecimal(int a, BigDecimal b)
455: throws SQLException {
456: inner.setBigDecimal(a, b);
457: }
458:
459: public synchronized void setBytes(int a, byte[] b)
460: throws SQLException {
461: inner.setBytes(a, b);
462: }
463:
464: public synchronized void setTimestamp(int a, Timestamp b, Calendar c)
465: throws SQLException {
466: inner.setTimestamp(a, b, c);
467: }
468:
469: public synchronized void setTimestamp(int a, Timestamp b)
470: throws SQLException {
471: inner.setTimestamp(a, b);
472: }
473:
474: public synchronized void setAsciiStream(int a, InputStream b, int c)
475: throws SQLException {
476: inner.setAsciiStream(a, b, c);
477: }
478:
479: public synchronized void setUnicodeStream(int a, InputStream b,
480: int c) throws SQLException {
481: inner.setUnicodeStream(a, b, c);
482: }
483:
484: public synchronized void setBinaryStream(int a, InputStream b, int c)
485: throws SQLException {
486: inner.setBinaryStream(a, b, c);
487: }
488:
489: public synchronized void clearParameters() throws SQLException {
490: inner.clearParameters();
491: }
492:
493: public synchronized void setObject(int a, Object b)
494: throws SQLException {
495: inner.setObject(a, b);
496: }
497:
498: public synchronized void setObject(int a, Object b, int c, int d)
499: throws SQLException {
500: inner.setObject(a, b, c, d);
501: }
502:
503: public synchronized void setObject(int a, Object b, int c)
504: throws SQLException {
505: inner.setObject(a, b, c);
506: }
507:
508: public synchronized void setCharacterStream(int a, Reader b, int c)
509: throws SQLException {
510: inner.setCharacterStream(a, b, c);
511: }
512:
513: public synchronized void setRef(int a, Ref b) throws SQLException {
514: inner.setRef(a, b);
515: }
516:
517: public synchronized void setBlob(int a, Blob b) throws SQLException {
518: inner.setBlob(a, b);
519: }
520:
521: public synchronized void setClob(int a, Clob b) throws SQLException {
522: inner.setClob(a, b);
523: }
524:
525: public synchronized void setArray(int a, Array b)
526: throws SQLException {
527: inner.setArray(a, b);
528: }
529:
530: public synchronized ParameterMetaData getParameterMetaData()
531: throws SQLException {
532: return inner.getParameterMetaData();
533: }
534:
535: public synchronized void setBoolean(int a, boolean b)
536: throws SQLException {
537: inner.setBoolean(a, b);
538: }
539:
540: public synchronized void setByte(int a, byte b) throws SQLException {
541: inner.setByte(a, b);
542: }
543:
544: public synchronized void setShort(int a, short b)
545: throws SQLException {
546: inner.setShort(a, b);
547: }
548:
549: public synchronized void setInt(int a, int b) throws SQLException {
550: inner.setInt(a, b);
551: }
552:
553: public synchronized void setLong(int a, long b) throws SQLException {
554: inner.setLong(a, b);
555: }
556:
557: public synchronized void setFloat(int a, float b)
558: throws SQLException {
559: inner.setFloat(a, b);
560: }
561:
562: public synchronized void setDouble(int a, double b)
563: throws SQLException {
564: inner.setDouble(a, b);
565: }
566:
567: public synchronized void setURL(int a, URL b) throws SQLException {
568: inner.setURL(a, b);
569: }
570:
571: public synchronized void setTime(int a, Time b) throws SQLException {
572: inner.setTime(a, b);
573: }
574:
575: public synchronized void setTime(int a, Time b, Calendar c)
576: throws SQLException {
577: inner.setTime(a, b, c);
578: }
579:
580: public synchronized boolean execute() throws SQLException {
581: return inner.execute();
582: }
583:
584: public synchronized void setString(int a, String b)
585: throws SQLException {
586: inner.setString(a, b);
587: }
588:
589: public synchronized void setDate(int a, Date b, Calendar c)
590: throws SQLException {
591: inner.setDate(a, b, c);
592: }
593:
594: public synchronized void setDate(int a, Date b) throws SQLException {
595: inner.setDate(a, b);
596: }
597:
598: public synchronized SQLWarning getWarnings() throws SQLException {
599: return inner.getWarnings();
600: }
601:
602: public synchronized void clearWarnings() throws SQLException {
603: inner.clearWarnings();
604: }
605:
606: public synchronized void setFetchDirection(int a)
607: throws SQLException {
608: inner.setFetchDirection(a);
609: }
610:
611: public synchronized int getFetchDirection() throws SQLException {
612: return inner.getFetchDirection();
613: }
614:
615: public synchronized void setFetchSize(int a) throws SQLException {
616: inner.setFetchSize(a);
617: }
618:
619: public synchronized int getFetchSize() throws SQLException {
620: return inner.getFetchSize();
621: }
622:
623: public synchronized int getResultSetHoldability()
624: throws SQLException {
625: return inner.getResultSetHoldability();
626: }
627:
628: public synchronized ResultSet executeQuery(String a)
629: throws SQLException {
630: return inner.executeQuery(a);
631: }
632:
633: public synchronized int executeUpdate(String a, int b)
634: throws SQLException {
635: return inner.executeUpdate(a, b);
636: }
637:
638: public synchronized int executeUpdate(String a, String[] b)
639: throws SQLException {
640: return inner.executeUpdate(a, b);
641: }
642:
643: public synchronized int executeUpdate(String a, int[] b)
644: throws SQLException {
645: return inner.executeUpdate(a, b);
646: }
647:
648: public synchronized int executeUpdate(String a) throws SQLException {
649: return inner.executeUpdate(a);
650: }
651:
652: public synchronized int getMaxFieldSize() throws SQLException {
653: return inner.getMaxFieldSize();
654: }
655:
656: public synchronized void setMaxFieldSize(int a) throws SQLException {
657: inner.setMaxFieldSize(a);
658: }
659:
660: public synchronized int getMaxRows() throws SQLException {
661: return inner.getMaxRows();
662: }
663:
664: public synchronized void setMaxRows(int a) throws SQLException {
665: inner.setMaxRows(a);
666: }
667:
668: public synchronized void setEscapeProcessing(boolean a)
669: throws SQLException {
670: inner.setEscapeProcessing(a);
671: }
672:
673: public synchronized int getQueryTimeout() throws SQLException {
674: return inner.getQueryTimeout();
675: }
676:
677: public synchronized void setQueryTimeout(int a) throws SQLException {
678: inner.setQueryTimeout(a);
679: }
680:
681: public synchronized void setCursorName(String a)
682: throws SQLException {
683: inner.setCursorName(a);
684: }
685:
686: public synchronized ResultSet getResultSet() throws SQLException {
687: return inner.getResultSet();
688: }
689:
690: public synchronized int getUpdateCount() throws SQLException {
691: return inner.getUpdateCount();
692: }
693:
694: public synchronized boolean getMoreResults() throws SQLException {
695: return inner.getMoreResults();
696: }
697:
698: public synchronized boolean getMoreResults(int a)
699: throws SQLException {
700: return inner.getMoreResults(a);
701: }
702:
703: public synchronized int getResultSetConcurrency()
704: throws SQLException {
705: return inner.getResultSetConcurrency();
706: }
707:
708: public synchronized int getResultSetType() throws SQLException {
709: return inner.getResultSetType();
710: }
711:
712: public synchronized void addBatch(String a) throws SQLException {
713: inner.addBatch(a);
714: }
715:
716: public synchronized void clearBatch() throws SQLException {
717: inner.clearBatch();
718: }
719:
720: public synchronized int[] executeBatch() throws SQLException {
721: return inner.executeBatch();
722: }
723:
724: public synchronized ResultSet getGeneratedKeys()
725: throws SQLException {
726: return inner.getGeneratedKeys();
727: }
728:
729: public synchronized void close() throws SQLException {
730: inner.close();
731: }
732:
733: public synchronized boolean execute(String a, int b)
734: throws SQLException {
735: return inner.execute(a, b);
736: }
737:
738: public synchronized boolean execute(String a) throws SQLException {
739: return inner.execute(a);
740: }
741:
742: public synchronized boolean execute(String a, int[] b)
743: throws SQLException {
744: return inner.execute(a, b);
745: }
746:
747: public synchronized boolean execute(String a, String[] b)
748: throws SQLException {
749: return inner.execute(a, b);
750: }
751:
752: public synchronized Connection getConnection() throws SQLException {
753: return inner.getConnection();
754: }
755:
756: public synchronized void cancel() throws SQLException {
757: inner.cancel();
758: }
759: }
|