KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > dbforms > conprovider > SingleConnectionWrapper


1 /*
2  * $Header: /cvsroot/jdbforms/dbforms/src/org/dbforms/conprovider/SingleConnectionWrapper.java,v 1.13 2004/10/20 10:51:29 hkollmann Exp $
3  * $Revision: 1.13 $
4  * $Date: 2004/10/20 10:51:29 $
5  *
6  * DbForms - a Rapid Application Development Framework
7  * Copyright (C) 2001 Joachim Peer <joepeer@excite.com>
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  */

23
24 package org.dbforms.conprovider;
25
26 import org.apache.commons.logging.Log;
27 import org.apache.commons.logging.LogFactory;
28
29 import java.sql.CallableStatement JavaDoc;
30 import java.sql.Connection JavaDoc;
31 import java.sql.DatabaseMetaData JavaDoc;
32 import java.sql.PreparedStatement JavaDoc;
33 import java.sql.SQLException JavaDoc;
34 import java.sql.SQLWarning JavaDoc;
35 import java.sql.Statement JavaDoc;
36
37 import java.util.ArrayList JavaDoc;
38 import java.util.Iterator JavaDoc;
39 import java.util.List JavaDoc;
40 import java.util.Map JavaDoc;
41
42
43
44 /**
45  * DOCUMENT ME!
46  *
47  * @author $author$
48  * @version $Revision: 1.13 $
49  */

50 public class SingleConnectionWrapper implements Connection JavaDoc {
51    private static Log logCat = LogFactory.getLog(SingleConnectionWrapper.class
52                                                  .getName());
53    private Connection JavaDoc _conn;
54    private List JavaDoc list = new ArrayList JavaDoc();
55    private boolean open = true;
56
57    /**
58     * Creates a new SingleConnectionWrapper object.
59     *
60     * @param con DOCUMENT ME!
61     */

62    public SingleConnectionWrapper(Connection JavaDoc con) {
63       _conn = con;
64    }
65
66    /**
67     * DOCUMENT ME!
68     *
69     * @param autoCommit DOCUMENT ME!
70     *
71     * @throws SQLException DOCUMENT ME!
72     */

73    public void setAutoCommit(boolean autoCommit) throws SQLException JavaDoc {
74       synchronized (_conn) {
75          _conn.setAutoCommit(autoCommit);
76       }
77    }
78
79
80    /**
81     * DOCUMENT ME!
82     *
83     * @return DOCUMENT ME!
84     *
85     * @throws SQLException DOCUMENT ME!
86     */

87    public boolean getAutoCommit() throws SQLException JavaDoc {
88       synchronized (_conn) {
89          return _conn.getAutoCommit();
90       }
91    }
92
93
94    /**
95     * DOCUMENT ME!
96     *
97     * @param catalog DOCUMENT ME!
98     *
99     * @throws SQLException DOCUMENT ME!
100     */

101    public void setCatalog(String JavaDoc catalog) throws SQLException JavaDoc {
102       synchronized (_conn) {
103          _conn.setCatalog(catalog);
104       }
105    }
106
107
108    /**
109     * DOCUMENT ME!
110     *
111     * @return DOCUMENT ME!
112     *
113     * @throws SQLException DOCUMENT ME!
114     */

115    public String JavaDoc getCatalog() throws SQLException JavaDoc {
116       synchronized (_conn) {
117          return _conn.getCatalog();
118       }
119    }
120
121
122    /**
123     * DOCUMENT ME!
124     *
125     * @return DOCUMENT ME!
126     *
127     * @throws SQLException DOCUMENT ME!
128     */

129    public boolean isClosed() throws SQLException JavaDoc {
130       synchronized (_conn) {
131          return !open || _conn.isClosed();
132       }
133    }
134
135
136    /**
137     * DOCUMENT ME!
138     *
139     * @param holdability DOCUMENT ME!
140     *
141     * @throws SQLException DOCUMENT ME!
142     */

143    public void setHoldability(int holdability) throws SQLException JavaDoc {
144       synchronized (_conn) {
145          _conn.setHoldability(holdability);
146       }
147    }
148
149
150    /**
151     * DOCUMENT ME!
152     *
153     * @return DOCUMENT ME!
154     *
155     * @throws SQLException DOCUMENT ME!
156     */

157    public int getHoldability() throws SQLException JavaDoc {
158       synchronized (_conn) {
159          return _conn.getHoldability();
160       }
161    }
162
163
164    /**
165     * DOCUMENT ME!
166     *
167     * @return DOCUMENT ME!
168     *
169     * @throws SQLException DOCUMENT ME!
170     */

171    public DatabaseMetaData JavaDoc getMetaData() throws SQLException JavaDoc {
172       synchronized (_conn) {
173          return _conn.getMetaData();
174       }
175    }
176
177
178    /**
179     * DOCUMENT ME!
180     *
181     * @param readOnly DOCUMENT ME!
182     *
183     * @throws SQLException DOCUMENT ME!
184     */

185    public void setReadOnly(boolean readOnly) throws SQLException JavaDoc {
186       synchronized (_conn) {
187          _conn.setReadOnly(readOnly);
188       }
189    }
190
191
192    /**
193     * DOCUMENT ME!
194     *
195     * @return DOCUMENT ME!
196     *
197     * @throws SQLException DOCUMENT ME!
198     */

199    public boolean isReadOnly() throws SQLException JavaDoc {
200       synchronized (_conn) {
201          return _conn.isReadOnly();
202       }
203    }
204
205
206    /**
207     * DOCUMENT ME!
208     *
209     * @return DOCUMENT ME!
210     *
211     * @throws SQLException DOCUMENT ME!
212     */

213    public java.sql.Savepoint JavaDoc setSavepoint() throws SQLException JavaDoc {
214       synchronized (_conn) {
215          return _conn.setSavepoint();
216       }
217    }
218
219
220    /**
221     * DOCUMENT ME!
222     *
223     * @param name DOCUMENT ME!
224     *
225     * @return DOCUMENT ME!
226     *
227     * @throws SQLException DOCUMENT ME!
228     */

229    public java.sql.Savepoint JavaDoc setSavepoint(String JavaDoc name)
230                                    throws SQLException JavaDoc {
231       synchronized (_conn) {
232          return _conn.setSavepoint(name);
233       }
234    }
235
236
237    /**
238     * DOCUMENT ME!
239     *
240     * @param level DOCUMENT ME!
241     *
242     * @throws SQLException DOCUMENT ME!
243     */

244    public void setTransactionIsolation(int level) throws SQLException JavaDoc {
245       synchronized (_conn) {
246          _conn.setTransactionIsolation(level);
247       }
248    }
249
250
251    /**
252     * DOCUMENT ME!
253     *
254     * @return DOCUMENT ME!
255     *
256     * @throws SQLException DOCUMENT ME!
257     */

258    public int getTransactionIsolation() throws SQLException JavaDoc {
259       synchronized (_conn) {
260          return _conn.getTransactionIsolation();
261       }
262    }
263
264
265    /**
266     * DOCUMENT ME!
267     *
268     * @param map DOCUMENT ME!
269     *
270     * @throws SQLException DOCUMENT ME!
271     */

272    public void setTypeMap(Map JavaDoc map) throws SQLException JavaDoc {
273       synchronized (_conn) {
274          _conn.setTypeMap(map);
275       }
276    }
277
278
279    /**
280     * DOCUMENT ME!
281     *
282     * @return DOCUMENT ME!
283     *
284     * @throws SQLException DOCUMENT ME!
285     */

286    public Map JavaDoc getTypeMap() throws SQLException JavaDoc {
287       synchronized (_conn) {
288          return _conn.getTypeMap();
289       }
290    }
291
292
293    /**
294     * DOCUMENT ME!
295     *
296     * @return DOCUMENT ME!
297     *
298     * @throws SQLException DOCUMENT ME!
299     */

300    public SQLWarning JavaDoc getWarnings() throws SQLException JavaDoc {
301       synchronized (_conn) {
302          return _conn.getWarnings();
303       }
304    }
305
306
307    /**
308     * DOCUMENT ME!
309     *
310     * @throws SQLException DOCUMENT ME!
311     */

312    public void clearWarnings() throws SQLException JavaDoc {
313       synchronized (_conn) {
314          _conn.clearWarnings();
315       }
316    }
317
318
319    /**
320     * Close only statements of this connection! do not close the connection!
321     */

322    public void close() throws SQLException JavaDoc {
323       synchronized (_conn) {
324          Iterator JavaDoc iter = list.iterator();
325
326          while (iter.hasNext()) {
327             Statement JavaDoc stmt = (Statement JavaDoc) iter.next();
328
329             try {
330                stmt.close();
331             } catch (SQLException JavaDoc e) {
332 // logCat.info("close", e);
333
;
334             } catch (Exception JavaDoc e) {
335                logCat.error(e);
336             }
337          }
338
339          list.clear();
340          open = false;
341       }
342    }
343
344
345    /**
346     * DOCUMENT ME!
347     *
348     * @throws SQLException DOCUMENT ME!
349     */

350    public void closeReally() throws SQLException JavaDoc {
351       synchronized (_conn) {
352          if (!_conn.isClosed()) {
353             _conn.close();
354          }
355       }
356    }
357
358
359    /**
360     * DOCUMENT ME!
361     *
362     * @throws SQLException DOCUMENT ME!
363     */

364    public void commit() throws SQLException JavaDoc {
365       synchronized (_conn) {
366          _conn.commit();
367       }
368    }
369
370
371    /**
372     * DOCUMENT ME!
373     *
374     * @return DOCUMENT ME!
375     *
376     * @throws SQLException DOCUMENT ME!
377     */

378    public Statement JavaDoc createStatement() throws SQLException JavaDoc {
379       synchronized (_conn) {
380          Statement JavaDoc res = _conn.createStatement();
381          list.add(res);
382
383          return res;
384       }
385    }
386
387
388    /**
389     * DOCUMENT ME!
390     *
391     * @param resultSetType DOCUMENT ME!
392     * @param resultSetConcurrency DOCUMENT ME!
393     *
394     * @return DOCUMENT ME!
395     *
396     * @throws SQLException DOCUMENT ME!
397     */

398    public Statement JavaDoc createStatement(int resultSetType,
399                                     int resultSetConcurrency)
400                              throws SQLException JavaDoc {
401       synchronized (_conn) {
402          Statement JavaDoc res = _conn.createStatement(resultSetType,
403                                                resultSetConcurrency);
404          list.add(res);
405
406          return res;
407       }
408    }
409
410
411    /**
412     * DOCUMENT ME!
413     *
414     * @param resultSetType DOCUMENT ME!
415     * @param resultSetConcurrency DOCUMENT ME!
416     * @param resultSetHoldability DOCUMENT ME!
417     *
418     * @return DOCUMENT ME!
419     *
420     * @throws SQLException DOCUMENT ME!
421     */

422    public Statement JavaDoc createStatement(int resultSetType,
423                                     int resultSetConcurrency,
424                                     int resultSetHoldability)
425                              throws SQLException JavaDoc {
426       synchronized (_conn) {
427          Statement JavaDoc res = _conn.createStatement(resultSetType,
428                                                resultSetConcurrency,
429                                                resultSetHoldability);
430          list.add(res);
431
432          return res;
433       }
434    }
435
436
437    /**
438     * DOCUMENT ME!
439     *
440     * @param sql DOCUMENT ME!
441     *
442     * @return DOCUMENT ME!
443     *
444     * @throws SQLException DOCUMENT ME!
445     */

446    public String JavaDoc nativeSQL(String JavaDoc sql) throws SQLException JavaDoc {
447       synchronized (_conn) {
448          return _conn.nativeSQL(sql);
449       }
450    }
451
452
453    /**
454     * DOCUMENT ME!
455     *
456     * @param sql DOCUMENT ME!
457     *
458     * @return DOCUMENT ME!
459     *
460     * @throws SQLException DOCUMENT ME!
461     */

462    public CallableStatement JavaDoc prepareCall(String JavaDoc sql) throws SQLException JavaDoc {
463       synchronized (_conn) {
464          CallableStatement JavaDoc res = _conn.prepareCall(sql);
465          list.add(res);
466
467          return res;
468       }
469    }
470
471
472    /**
473     * DOCUMENT ME!
474     *
475     * @param sql DOCUMENT ME!
476     * @param resultSetType DOCUMENT ME!
477     * @param resultSetConcurrency DOCUMENT ME!
478     *
479     * @return DOCUMENT ME!
480     *
481     * @throws SQLException DOCUMENT ME!
482     */

483    public CallableStatement JavaDoc prepareCall(String JavaDoc sql,
484                                         int resultSetType,
485                                         int resultSetConcurrency)
486                                  throws SQLException JavaDoc {
487       synchronized (_conn) {
488          CallableStatement JavaDoc res = _conn.prepareCall(sql, resultSetType,
489                                                    resultSetConcurrency);
490          list.add(res);
491
492          return res;
493       }
494    }
495
496
497    /**
498     * DOCUMENT ME!
499     *
500     * @param sql DOCUMENT ME!
501     * @param resultSetType DOCUMENT ME!
502     * @param resultSetConcurrency DOCUMENT ME!
503     * @param resultSetHoldability DOCUMENT ME!
504     *
505     * @return DOCUMENT ME!
506     *
507     * @throws SQLException DOCUMENT ME!
508     */

509    public CallableStatement JavaDoc prepareCall(String JavaDoc sql,
510                                         int resultSetType,
511                                         int resultSetConcurrency,
512                                         int resultSetHoldability)
513                                  throws SQLException JavaDoc {
514       synchronized (_conn) {
515          CallableStatement JavaDoc res = _conn.prepareCall(sql, resultSetType,
516                                                    resultSetConcurrency,
517                                                    resultSetHoldability);
518          list.add(res);
519
520          return res;
521       }
522    }
523
524
525    /**
526     * DOCUMENT ME!
527     *
528     * @param sql DOCUMENT ME!
529     *
530     * @return DOCUMENT ME!
531     *
532     * @throws SQLException DOCUMENT ME!
533     */

534    public PreparedStatement JavaDoc prepareStatement(String JavaDoc sql)
535                                       throws SQLException JavaDoc {
536       synchronized (_conn) {
537          PreparedStatement JavaDoc res = _conn.prepareStatement(sql);
538          list.add(res);
539
540          return res;
541       }
542    }
543
544
545    /**
546     * DOCUMENT ME!
547     *
548     * @param sql DOCUMENT ME!
549     * @param resultSetType DOCUMENT ME!
550     * @param resultSetConcurrency DOCUMENT ME!
551     *
552     * @return DOCUMENT ME!
553     *
554     * @throws SQLException DOCUMENT ME!
555     */

556    public PreparedStatement JavaDoc prepareStatement(String JavaDoc sql,
557                                              int resultSetType,
558                                              int resultSetConcurrency)
559                                       throws SQLException JavaDoc {
560       synchronized (_conn) {
561          PreparedStatement JavaDoc res = _conn.prepareStatement(sql, resultSetType,
562                                                         resultSetConcurrency);
563          list.add(res);
564
565          return res;
566       }
567    }
568
569
570    /**
571     * DOCUMENT ME!
572     *
573     * @param sql DOCUMENT ME!
574     * @param resultSetType DOCUMENT ME!
575     * @param resultSetConcurrency DOCUMENT ME!
576     * @param resultSetHoldability DOCUMENT ME!
577     *
578     * @return DOCUMENT ME!
579     *
580     * @throws SQLException DOCUMENT ME!
581     */

582    public PreparedStatement JavaDoc prepareStatement(String JavaDoc sql,
583                                              int resultSetType,
584                                              int resultSetConcurrency,
585                                              int resultSetHoldability)
586                                       throws SQLException JavaDoc {
587       synchronized (_conn) {
588          PreparedStatement JavaDoc res = _conn.prepareStatement(sql, resultSetType,
589                                                         resultSetConcurrency,
590                                                         resultSetHoldability);
591          list.add(res);
592
593          return res;
594       }
595    }
596
597
598    /**
599     * DOCUMENT ME!
600     *
601     * @param sql DOCUMENT ME!
602     * @param autoGeneratedKeys DOCUMENT ME!
603     *
604     * @return DOCUMENT ME!
605     *
606     * @throws SQLException DOCUMENT ME!
607     */

608    public PreparedStatement JavaDoc prepareStatement(String JavaDoc sql,
609                                              int autoGeneratedKeys)
610                                       throws SQLException JavaDoc {
611       synchronized (_conn) {
612          PreparedStatement JavaDoc res = _conn.prepareStatement(sql, autoGeneratedKeys);
613          list.add(res);
614
615          return res;
616       }
617    }
618
619
620    /**
621     * DOCUMENT ME!
622     *
623     * @param sql DOCUMENT ME!
624     * @param columnIndexes DOCUMENT ME!
625     *
626     * @return DOCUMENT ME!
627     *
628     * @throws SQLException DOCUMENT ME!
629     */

630    public PreparedStatement JavaDoc prepareStatement(String JavaDoc sql,
631                                              int[] columnIndexes)
632                                       throws SQLException JavaDoc {
633       synchronized (_conn) {
634          PreparedStatement JavaDoc res = _conn.prepareStatement(sql, columnIndexes);
635          list.add(res);
636
637          return res;
638       }
639    }
640
641
642    /**
643     * DOCUMENT ME!
644     *
645     * @param sql DOCUMENT ME!
646     * @param columnNames DOCUMENT ME!
647     *
648     * @return DOCUMENT ME!
649     *
650     * @throws SQLException DOCUMENT ME!
651     */

652    public PreparedStatement JavaDoc prepareStatement(String JavaDoc sql,
653                                              String JavaDoc[] columnNames)
654                                       throws SQLException JavaDoc {
655       synchronized (_conn) {
656          PreparedStatement JavaDoc res = _conn.prepareStatement(sql, columnNames);
657          list.add(res);
658
659          return res;
660       }
661    }
662
663
664    /**
665     * DOCUMENT ME!
666     *
667     * @param savepoint DOCUMENT ME!
668     *
669     * @throws SQLException DOCUMENT ME!
670     */

671    public void releaseSavepoint(java.sql.Savepoint JavaDoc savepoint)
672                          throws SQLException JavaDoc {
673       synchronized (_conn) {
674          _conn.releaseSavepoint(savepoint);
675       }
676    }
677
678
679    /**
680     * DOCUMENT ME!
681     *
682     * @throws SQLException DOCUMENT ME!
683     */

684    public void rollback() throws SQLException JavaDoc {
685       synchronized (_conn) {
686          _conn.rollback();
687       }
688    }
689
690
691    /**
692     * DOCUMENT ME!
693     *
694     * @param savepoint DOCUMENT ME!
695     *
696     * @throws SQLException DOCUMENT ME!
697     */

698    public void rollback(java.sql.Savepoint JavaDoc savepoint) throws SQLException JavaDoc {
699       synchronized (_conn) {
700          _conn.rollback(savepoint);
701       }
702    }
703 }
704
Popular Tags