Ubuntu
jbossas4 package

Merge lp:~scarneiro/ubuntu/quantal/jbossas4/fix-for-888943 into lp:ubuntu/quantal/jbossas4

  1. Quantal (12.10)
  2. fix-for-888943
  3. Merge into quantal
Proposed by Sebastian Carneiro
Status: Merged
Merge reported by: James Page
Merged at revision: not available
Proposed branch: lp:~scarneiro/ubuntu/quantal/jbossas4/fix-for-888943
Merge into: lp:ubuntu/quantal/jbossas4
Diff against target: 3596 lines (+3406/-21)
5 files modified
debian/build.xml (+21/-21)
debian/changelog (+12/-0)
debian/patches/ejb3-jdk7.diff (+36/-0)
debian/patches/jdk7-jdbc.diff (+3335/-0)
debian/patches/series (+2/-0)
To merge this branch: bzr merge lp:~scarneiro/ubuntu/quantal/jbossas4/fix-for-888943
Reviewer Review Type Date Requested Status
Michael Terry Approve
Ubuntu branches Pending
Review via email: mp+125628@code.launchpad.net

Description of the change

The following changes are in this merge proposal:

* Fix for FTBFS in quantal with Java7:
  - Added Java7 implementations for JDBC Resource Adapters.
  - Added lookup attribute to Resource Annotation
  - set encoding to javac targets in build.xml

To post a comment you must log in.
Revision history for this message
Michael Terry (mterry) wrote :

Looks fine, fixes FTBFS for me. I uploaded to quantal, it's waiting for approval.

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'debian/build.xml'
2--- debian/build.xml 2010-04-15 18:01:56 +0000
3+++ debian/build.xml 2012-09-21 04:33:21 +0000
4@@ -57,7 +57,7 @@
5 <target name="jar">
6 <mkdir dir="${test.dir}/${class.dir}"/>
7 <javac srcdir="${test.dir}/${source.dir}" destdir="${test.dir}/${class.dir}"
8- debug="true"/>
9+ debug="true" encoding="ISO-8859-1" />
10
11 <jar jarfile="${test.jar}">
12 <fileset dir="${test.dir}/${class.dir}">
13@@ -67,7 +67,7 @@
14
15 <mkdir dir="${ejb3x.dir}/${class.dir}"/>
16 <javac srcdir="${ejb3x.dir}/${source.dir}" destdir="${ejb3x.dir}/${class.dir}"
17- debug="true" source="1.5"/>
18+ debug="true" encoding="ISO-8859-1" source="1.5"/>
19
20 <jar jarfile="${ejb3x.jar}">
21 <fileset dir="${ejb3x.dir}/${class.dir}">
22@@ -77,7 +77,7 @@
23
24 <mkdir dir="${jmx.dir}/${class.dir}"/>
25 <javac srcdir="${jmx.dir}/${source.dir}" destdir="${jmx.dir}/${class.dir}"
26- debug="true"/>
27+ debug="true" encoding="ISO-8859-1" />
28
29 <!-- The upstream build.xml builds some more jars with partial
30 content only. Do we need to build them? -->
31@@ -90,7 +90,7 @@
32
33 <mkdir dir="${system.dir}/${class.dir}"/>
34 <javac srcdir="${system.dir}/${source.dir}" destdir="${system.dir}/${class.dir}"
35- debug="true" classpath="jboss-jmx.jar"/>
36+ debug="true" encoding="ISO-8859-1" classpath="jboss-jmx.jar"/>
37
38 <!-- The upstream build.xml builds some more jars with partial
39 content only. Do we need to build them? -->
40@@ -102,7 +102,7 @@
41
42 <mkdir dir="${j2ee.dir}/${class.dir}"/>
43 <javac srcdir="${j2ee.dir}/${source.dir}" destdir="${j2ee.dir}/${class.dir}"
44- debug="true" source="1.5"/>
45+ debug="true" encoding="ISO-8859-1" source="1.5"/>
46
47 <!-- The upstream build.xml builds some more jars with partial
48 content only. Do we need to build them? Additionally it builds
49@@ -116,7 +116,7 @@
50
51 <mkdir dir="${jaxrpc.dir}/${class.dir}"/>
52 <javac srcdir="${jaxrpc.dir}/${source.dir}" destdir="${jaxrpc.dir}/${class.dir}"
53- debug="true"/>
54+ debug="true" encoding="ISO-8859-1" />
55
56 <jar jarfile="${jaxrpc.jar}">
57 <fileset dir="${jaxrpc.dir}/${class.dir}">
58@@ -126,7 +126,7 @@
59
60 <mkdir dir="${naming.dir}/${class.dir}"/>
61 <javac srcdir="${naming.dir}/${source.dir}" destdir="${naming.dir}/${class.dir}"
62- debug="true"/>
63+ debug="true" encoding="ISO-8859-1" />
64
65 <jar jarfile="${jnpserver.jar}">
66 <fileset dir="${naming.dir}/${class.dir}">
67@@ -147,7 +147,7 @@
68
69 <mkdir dir="${deployment.dir}/${class.dir}"/>
70 <javac srcdir="${deployment.dir}/${source.dir}" destdir="${deployment.dir}/${class.dir}"
71- debug="true">
72+ debug="true" encoding="ISO-8859-1">
73 <classpath>
74 <fileset dir=".">
75 <include name='*.jar'/>
76@@ -163,7 +163,7 @@
77
78 <mkdir dir="${transaction.dir}/${class.dir}"/>
79 <javac srcdir="${transaction.dir}/${source.dir}" destdir="${transaction.dir}/${class.dir}"
80- debug="true">
81+ debug="true" encoding="ISO-8859-1">
82 <classpath>
83 <fileset dir=".">
84 <include name='*.jar'/>
85@@ -182,7 +182,7 @@
86 target="security/src/main/org/jboss/security/auth/login/SunConfigParser.jj"
87 javacchome="/usr/share/java/" static="false" debugparser="true"/>
88 <javac srcdir="${security.dir}/${source.dir}" destdir="${security.dir}/${class.dir}"
89- debug="true" source="1.5">
90+ debug="true" encoding="ISO-8859-1" source="1.5">
91 <classpath>
92 <fileset dir=".">
93 <include name='*.jar'/>
94@@ -201,7 +201,7 @@
95 <mkdir dir="${server.dir}/${class.dir}"/>
96 <javac srcdir="${server.dir}/${source.dir}" destdir="${server.dir}/${class.dir}"
97 includes="**/invocation/**,**/Shutdown.java,**/logging/**,**/naming/NamingService*.java,**/jms/**,**/jmx/**,**/metadata/**,**/proxy/**,**/deployment/**"
98- debug="true" target="1.5" source="1.5">
99+ debug="true" target="1.5" source="1.5" encoding="ISO-8859-1">
100 <classpath>
101 <fileset dir=".">
102 <include name='*.jar'/>
103@@ -220,7 +220,7 @@
104 target="messaging/src/main/org/jboss/mq/selectors/SelectorParser.jj"
105 javacchome="/usr/share/java/" static="false" debugparser="true"/>
106 <javac srcdir="${messaging.dir}/${source.dir}" destdir="${messaging.dir}/${class.dir}"
107- debug="true" source="1.5">
108+ debug="true" source="1.5" encoding="ISO-8859-1">
109 <classpath>
110 <fileset dir=".">
111 <include name='*.jar'/>
112@@ -237,7 +237,7 @@
113 <mkdir dir="${management.dir}/${class.dir}"/>
114 <javac srcdir="${management.dir}/${source.dir}" destdir="${management.dir}/${class.dir}"
115 includes="org/jboss/management/j2ee/**" excludes="**/cluster/**,**/factory/EJB*.java,**/factory/RAR*.java"
116- debug="true">
117+ debug="true" encoding="ISO-8859-1">
118 <classpath>
119 <fileset dir=".">
120 <include name='*.jar'/>
121@@ -254,7 +254,7 @@
122
123 <mkdir dir="${remoting.dir}/${class.dir}"/>
124 <javac srcdir="${remoting.dir}/${source.dir}" destdir="${remoting.dir}/${class.dir}"
125- debug="true">
126+ debug="true" encoding="ISO-8859-1">
127 <classpath>
128 <fileset dir=".">
129 <include name='*.jar'/>
130@@ -270,7 +270,7 @@
131
132 <mkdir dir="${jms.dir}/${class.dir}"/>
133 <javac srcdir="${jms.dir}/${source.dir}" destdir="${jms.dir}/${class.dir}"
134- debug="true">
135+ debug="true" encoding="ISO-8859-1">
136 <classpath>
137 <fileset dir=".">
138 <include name='*.jar'/>
139@@ -286,8 +286,8 @@
140
141 <mkdir dir="${connector.dir}/${class.dir}"/>
142 <javac srcdir="${connector.dir}/${source.dir}" destdir="${connector.dir}/${class.dir}"
143- debug="true" source="1.5" includes="**/*.java"
144- excludes="**/org/jboss/resource/adapter/jdbc/jdk5/*.java">
145+ debug="true" source="1.5" encoding="ISO-8859-1" includes="**/*.java"
146+ excludes="**/org/jboss/resource/adapter/jdbc/jdk5/*.java,**/org/jboss/resource/adapter/jdbc/jdk6/*.java">
147 <classpath>
148 <fileset dir=".">
149 <include name='*.jar'/>
150@@ -303,7 +303,7 @@
151
152 <mkdir dir="${cluster.dir}/${class.dir}"/>
153 <javac srcdir="${cluster.dir}/${source.dir}" destdir="${cluster.dir}/${class.dir}"
154- includes="**/framework/**" debug="true" source="1.5">
155+ includes="**/framework/**" debug="true" source="1.5" encoding="ISO-8859-1">
156 <classpath>
157 <fileset dir=".">
158 <include name='*.jar'/>
159@@ -320,7 +320,7 @@
160
161 <mkdir dir="${aspects.dir}/${class.dir}"/>
162 <javac srcdir="${aspects.dir}/${source.dir}" destdir="${aspects.dir}/${class.dir}"
163- excludes="**/deployment/**" debug="true" source="1.4">
164+ excludes="**/deployment/**" debug="true" source="1.4" encoding="ISO-8859-1">
165 <classpath>
166 <fileset dir=".">
167 <include name='*.jar'/>
168@@ -337,7 +337,7 @@
169 <mkdir dir="${ejb3.dir}/${class.dir}"/>
170 <javac srcdir="${ejb3.dir}/${source.dir}" destdir="${ejb3.dir}/${class.dir}"
171 excludes="**/deployers/**,**/embedded/**,**/iiop/**,**/naming/**,**/clientmodule/**,**/webservice/**"
172- debug="true" source="1.5">
173+ debug="true" source="1.5" encoding="ISO-8859-1">
174 <classpath>
175 <fileset dir=".">
176 <include name='*.jar'/>
177@@ -353,7 +353,7 @@
178
179 <mkdir dir="${webservices.dir}/${class.dir}"/>
180 <javac srcdir="${webservices.dir}/${source.dir}" destdir="${webservices.dir}/${class.dir}"
181- debug="true" source="1.5">
182+ debug="true" source="1.5" encoding="ISO-8859-1">
183 <classpath>
184 <fileset dir=".">
185 <include name='*.jar'/>
186
187=== modified file 'debian/changelog'
188--- debian/changelog 2012-03-02 22:57:23 +0000
189+++ debian/changelog 2012-09-21 04:33:21 +0000
190@@ -1,3 +1,15 @@
191+jbossas4 (4.2.3.GA-7ubuntu1) quantal; urgency=low
192+
193+ * Implement jdbc and ejb3 resource annotation for Java7, and
194+ set encoding on javac targets (LP: #888943)
195+ - debian/patches/jdbc-jdk7: added implementation of JDBC resource
196+ adapters for JDK7.
197+ - debian/patches/ejb3-jdk7: added lookup attribute to Resource
198+ annotation for JDK7.
199+ - debian/build.xml: set encoding on javac targets.
200+
201+ -- Sebastian Carneiro <scarneiro@fibertel.com.ar> Fri, 21 Sep 2012 01:21:48 -0300
202+
203 jbossas4 (4.2.3.GA-7) unstable; urgency=low
204
205 * Team upload.
206
207=== added file 'debian/patches/ejb3-jdk7.diff'
208--- debian/patches/ejb3-jdk7.diff 1970-01-01 00:00:00 +0000
209+++ debian/patches/ejb3-jdk7.diff 2012-09-21 04:33:21 +0000
210@@ -0,0 +1,36 @@
211+From: Sebastián Carneiro <scarneiro@fibertel.com.ar>
212+Description: Adds lookup attribute to Resource annotation.
213+Bug-Ubuntu: https://launchpad.net/bugs/888943
214+Forwarded: not-needed
215+Author: Sebastián Carneiro <scarneiro@fibertel.com.ar>
216+Last-Update: 2012-09-20
217+
218+Index: fix-for-888943/ejb3/src/main/org/jboss/ejb/ResourceImpl.java
219+===================================================================
220+--- fix-for-888943.orig/ejb3/src/main/org/jboss/ejb/ResourceImpl.java 2012-07-31 00:33:07.714445000 -0300
221++++ fix-for-888943/ejb3/src/main/org/jboss/ejb/ResourceImpl.java 2012-07-31 06:46:52.354537807 -0300
222+@@ -36,6 +36,7 @@
223+ private Class type = Object.class;
224+ private String description;
225+ private String mappedName;
226++ private String lookup;
227+
228+ public ResourceImpl()
229+ {
230+@@ -95,6 +96,16 @@
231+ this.shareable = shareable;
232+ }
233+
234++ public String lookup()
235++ {
236++ return lookup;
237++ }
238++
239++ public void setLookup(String lookup)
240++ {
241++ this.lookup = lookup;
242++ }
243++
244+ public Class annotationType()
245+ {
246+ return javax.annotation.Resource.class;
247
248=== added file 'debian/patches/jdk7-jdbc.diff'
249--- debian/patches/jdk7-jdbc.diff 1970-01-01 00:00:00 +0000
250+++ debian/patches/jdk7-jdbc.diff 2012-09-21 04:33:21 +0000
251@@ -0,0 +1,3335 @@
252+From: Sebastián Carneiro <scarneiro@fibertel.com.ar>
253+Description: Adds JDK7 implementation of JDBC resource
254+.adapters.
255+Bug-Ubuntu: https://launchpad.net/bugs/888943
256+Forwarded: not-needed
257+Author: Sebastián Carneiro <scarneiro@fibertel.com.ar>
258+Last-Update: 2012-09-20
259+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/WrapperDataSource.java
260+===================================================================
261+--- fix-for-888943.orig/connector/src/main/org/jboss/resource/adapter/jdbc/WrapperDataSource.java 2012-07-25 15:48:09.589627766 -0300
262++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/WrapperDataSource.java 2012-07-25 16:35:05.799592606 -0300
263+@@ -25,6 +25,9 @@
264+ import java.io.Serializable;
265+ import java.sql.Connection;
266+ import java.sql.SQLException;
267++import java.sql.SQLFeatureNotSupportedException;
268++
269++import java.util.logging.Logger;
270+
271+ import javax.naming.Reference;
272+ import javax.resource.Referenceable;
273+@@ -165,4 +168,14 @@
274+ throw new NestedSQLException(e);
275+ }
276+ }
277++
278++ /**
279++ * Return the parent logger of all loggers used by this datasource
280++ *
281++ * @throws SQLFeatureNotSupportedException if this datasource does not use java.util.logging
282++ */
283++ public Logger getParentLogger() throws SQLFeatureNotSupportedException
284++ {
285++ throw new SQLFeatureNotSupportedException("This datasource does not use logging");
286++ }
287+ }
288+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/CachedCallableStatementJDK7.java
289+===================================================================
290+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
291++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/CachedCallableStatementJDK7.java 2012-07-30 23:01:30.492080768 -0300
292+@@ -0,0 +1,333 @@
293++/*
294++ * JBoss, Home of Professional Open Source.
295++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
296++ * as indicated by the @author tags. See the copyright.txt file in the
297++ * distribution for a full listing of individual contributors.
298++ *
299++ * This is free software; you can redistribute it and/or modify it
300++ * under the terms of the GNU Lesser General Public License as
301++ * published by the Free Software Foundation; either version 2.1 of
302++ * the License, or (at your option) any later version.
303++ *
304++ * This software is distributed in the hope that it will be useful,
305++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
306++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
307++ * Lesser General Public License for more details.
308++ *
309++ * You should have received a copy of the GNU Lesser General Public
310++ * License along with this software; if not, write to the Free
311++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
312++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
313++ */
314++package org.jboss.resource.adapter.jdbc.jdk7;
315++
316++import java.io.InputStream;
317++import java.io.Reader;
318++import java.sql.Blob;
319++import java.sql.CallableStatement;
320++import java.sql.Clob;
321++import java.sql.NClob;
322++import java.sql.RowId;
323++import java.sql.SQLException;
324++import java.sql.SQLXML;
325++
326++import org.jboss.resource.adapter.jdbc.CachedCallableStatement;
327++
328++/**
329++ * CachedCallableStatementJDK7.
330++ *
331++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
332++ * @version $Revision: 1.1 $
333++ */
334++public class CachedCallableStatementJDK7 extends CachedCallableStatement
335++{
336++ public CachedCallableStatementJDK7(CallableStatement cs) throws SQLException
337++ {
338++ super(cs);
339++ }
340++
341++ public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException
342++ {
343++ getWrappedObject().setAsciiStream(parameterIndex, x, length);
344++ }
345++
346++ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException
347++ {
348++ getWrappedObject().setAsciiStream(parameterIndex, x);
349++ }
350++
351++ public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException
352++ {
353++ getWrappedObject().setBinaryStream(parameterIndex, x, length);
354++ }
355++
356++ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException
357++ {
358++ getWrappedObject().setBinaryStream(parameterIndex, x);
359++ }
360++
361++ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException
362++ {
363++ getWrappedObject().setBlob(parameterIndex, inputStream, length);
364++ }
365++
366++ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException
367++ {
368++ getWrappedObject().setBlob(parameterIndex, inputStream);
369++ }
370++
371++ public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException
372++ {
373++ getWrappedObject().setCharacterStream(parameterIndex, reader, length);
374++ }
375++
376++ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException
377++ {
378++ getWrappedObject().setCharacterStream(parameterIndex, reader);
379++ }
380++
381++ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException
382++ {
383++ getWrappedObject().setClob(parameterIndex, reader, length);
384++ }
385++
386++ public void setClob(int parameterIndex, Reader reader) throws SQLException
387++ {
388++ getWrappedObject().setClob(parameterIndex, reader);
389++ }
390++
391++ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException
392++ {
393++ getWrappedObject().setNCharacterStream(parameterIndex, value, length);
394++ }
395++
396++ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException
397++ {
398++ getWrappedObject().setNCharacterStream(parameterIndex, value);
399++ }
400++
401++ public void setNClob(int parameterIndex, NClob value) throws SQLException
402++ {
403++ getWrappedObject().setNClob(parameterIndex, value);
404++ }
405++
406++ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException
407++ {
408++ getWrappedObject().setNClob(parameterIndex, reader, length);
409++ }
410++
411++ public void setNClob(int parameterIndex, Reader reader) throws SQLException
412++ {
413++ getWrappedObject().setNClob(parameterIndex, reader);
414++ }
415++
416++ public void setNString(int parameterIndex, String value) throws SQLException
417++ {
418++ getWrappedObject().setNString(parameterIndex, value);
419++ }
420++
421++ public void setRowId(int parameterIndex, RowId x) throws SQLException
422++ {
423++ getWrappedObject().setRowId(parameterIndex, x);
424++ }
425++
426++ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException
427++ {
428++ getWrappedObject().setSQLXML(parameterIndex, xmlObject);
429++ }
430++
431++ public boolean isClosed() throws SQLException
432++ {
433++ return getWrappedObject().isClosed();
434++ }
435++
436++ public boolean isPoolable() throws SQLException
437++ {
438++ return getWrappedObject().isPoolable();
439++ }
440++
441++ public void setPoolable(boolean poolable) throws SQLException
442++ {
443++ getWrappedObject().setPoolable(poolable);
444++ }
445++
446++ public Reader getCharacterStream(int parameterIndex) throws SQLException
447++ {
448++ return getWrappedObject().getCharacterStream(parameterIndex);
449++ }
450++
451++ public Reader getCharacterStream(String parameterName) throws SQLException
452++ {
453++ return getWrappedObject().getCharacterStream(parameterName);
454++ }
455++
456++ public Reader getNCharacterStream(int parameterIndex) throws SQLException
457++ {
458++ return getWrappedObject().getNCharacterStream(parameterIndex);
459++ }
460++
461++ public Reader getNCharacterStream(String parameterName) throws SQLException
462++ {
463++ return getWrappedObject().getNCharacterStream(parameterName);
464++ }
465++
466++ public NClob getNClob(int parameterIndex) throws SQLException
467++ {
468++ return getWrappedObject().getNClob(parameterIndex);
469++ }
470++
471++ public NClob getNClob(String parameterName) throws SQLException
472++ {
473++ return getWrappedObject().getNClob(parameterName);
474++ }
475++
476++ public String getNString(int parameterIndex) throws SQLException
477++ {
478++ return getWrappedObject().getNString(parameterIndex);
479++ }
480++
481++ public String getNString(String parameterName) throws SQLException
482++ {
483++ return getWrappedObject().getNString(parameterName);
484++ }
485++
486++ public RowId getRowId(int parameterIndex) throws SQLException
487++ {
488++ return getWrappedObject().getRowId(parameterIndex);
489++ }
490++
491++ public RowId getRowId(String parameterName) throws SQLException
492++ {
493++ return getWrappedObject().getRowId(parameterName);
494++ }
495++
496++ public SQLXML getSQLXML(int parameterIndex) throws SQLException
497++ {
498++ return getWrappedObject().getSQLXML(parameterIndex);
499++ }
500++
501++ public SQLXML getSQLXML(String parameterName) throws SQLException
502++ {
503++ return getWrappedObject().getSQLXML(parameterName);
504++ }
505++
506++ public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException
507++ {
508++ getWrappedObject().setAsciiStream(parameterName, x, length);
509++ }
510++
511++ public void setAsciiStream(String parameterName, InputStream x) throws SQLException
512++ {
513++ getWrappedObject().setAsciiStream(parameterName, x);
514++ }
515++
516++ public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException
517++ {
518++ getWrappedObject().setBinaryStream(parameterName, x, length);
519++ }
520++
521++ public void setBinaryStream(String parameterName, InputStream x) throws SQLException
522++ {
523++ getWrappedObject().setBinaryStream(parameterName, x);
524++ }
525++
526++ public void setBlob(String parameterName, Blob x) throws SQLException
527++ {
528++ getWrappedObject().setBlob(parameterName, x);
529++ }
530++
531++ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException
532++ {
533++ getWrappedObject().setBlob(parameterName, inputStream, length);
534++ }
535++
536++ public void setBlob(String parameterName, InputStream inputStream) throws SQLException
537++ {
538++ getWrappedObject().setBlob(parameterName, inputStream);
539++ }
540++
541++ public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException
542++ {
543++ getWrappedObject().setCharacterStream(parameterName, reader, length);
544++ }
545++
546++ public void setCharacterStream(String parameterName, Reader reader) throws SQLException
547++ {
548++ getWrappedObject().setCharacterStream(parameterName, reader);
549++ }
550++
551++ public void setClob(String parameterName, Clob x) throws SQLException
552++ {
553++ getWrappedObject().setClob(parameterName, x);
554++ }
555++
556++ public void setClob(String parameterName, Reader reader, long length) throws SQLException
557++ {
558++ getWrappedObject().setClob(parameterName, reader, length);
559++ }
560++
561++ public void setClob(String parameterName, Reader reader) throws SQLException
562++ {
563++ getWrappedObject().setClob(parameterName, reader);
564++ }
565++
566++ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException
567++ {
568++ getWrappedObject().setNCharacterStream(parameterName, value, length);
569++ }
570++
571++ public void setNCharacterStream(String parameterName, Reader value) throws SQLException
572++ {
573++ getWrappedObject().setNCharacterStream(parameterName, value);
574++ }
575++
576++ public void setNClob(String parameterName, NClob value) throws SQLException
577++ {
578++ getWrappedObject().setNClob(parameterName, value);
579++ }
580++
581++ public void setNClob(String parameterName, Reader reader, long length) throws SQLException
582++ {
583++ getWrappedObject().setNClob(parameterName, reader, length);
584++ }
585++
586++ public void setNClob(String parameterName, Reader reader) throws SQLException
587++ {
588++ getWrappedObject().setNClob(parameterName, reader);
589++ }
590++
591++ public void setNString(String parameterName, String value) throws SQLException
592++ {
593++ getWrappedObject().setNString(parameterName, value);
594++ }
595++
596++ public void setRowId(String parameterName, RowId x) throws SQLException
597++ {
598++ getWrappedObject().setRowId(parameterName, x);
599++ }
600++
601++ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException
602++ {
603++ getWrappedObject().setSQLXML(parameterName, xmlObject);
604++ }
605++
606++ public boolean isCloseOnCompletion() throws SQLException
607++ {
608++ return getWrappedObject().isCloseOnCompletion();
609++ }
610++
611++ public void closeOnCompletion() throws SQLException
612++ {
613++ getWrappedObject().closeOnCompletion();
614++ }
615++
616++ public <T> T getObject(String parameterName, Class<T> type) throws SQLException
617++ {
618++ return getWrappedObject().getObject(parameterName, type);
619++ }
620++
621++ public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException
622++ {
623++ return getWrappedObject().getObject(parameterIndex, type);
624++ }
625++}
626+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/CachedPreparedStatementJDK7.java
627+===================================================================
628+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
629++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/CachedPreparedStatementJDK7.java 2012-07-30 20:03:39.642496177 -0300
630+@@ -0,0 +1,161 @@
631++/*
632++ * JBoss, Home of Professional Open Source.
633++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
634++ * as indicated by the @author tags. See the copyright.txt file in the
635++ * distribution for a full listing of individual contributors.
636++ *
637++ * This is free software; you can redistribute it and/or modify it
638++ * under the terms of the GNU Lesser General Public License as
639++ * published by the Free Software Foundation; either version 2.1 of
640++ * the License, or (at your option) any later version.
641++ *
642++ * This software is distributed in the hope that it will be useful,
643++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
644++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
645++ * Lesser General Public License for more details.
646++ *
647++ * You should have received a copy of the GNU Lesser General Public
648++ * License along with this software; if not, write to the Free
649++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
650++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
651++ */
652++package org.jboss.resource.adapter.jdbc.jdk7;
653++
654++import java.io.InputStream;
655++import java.io.Reader;
656++import java.sql.NClob;
657++import java.sql.PreparedStatement;
658++import java.sql.RowId;
659++import java.sql.SQLException;
660++import java.sql.SQLXML;
661++
662++import org.jboss.resource.adapter.jdbc.CachedPreparedStatement;
663++
664++/**
665++ * CachedPreparedStatementJDK5.
666++ *
667++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
668++ * @version $Revision: 1.1 $
669++ */
670++public class CachedPreparedStatementJDK7 extends CachedPreparedStatement
671++{
672++ public CachedPreparedStatementJDK7(PreparedStatement ps) throws SQLException
673++ {
674++ super(ps);
675++ }
676++
677++ public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException
678++ {
679++ getWrappedObject().setAsciiStream(parameterIndex, x, length);
680++ }
681++
682++ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException
683++ {
684++ getWrappedObject().setAsciiStream(parameterIndex, x);
685++ }
686++
687++ public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException
688++ {
689++ getWrappedObject().setBinaryStream(parameterIndex, x, length);
690++ }
691++
692++ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException
693++ {
694++ getWrappedObject().setBinaryStream(parameterIndex, x);
695++ }
696++
697++ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException
698++ {
699++ getWrappedObject().setBlob(parameterIndex, inputStream, length);
700++ }
701++
702++ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException
703++ {
704++ getWrappedObject().setBlob(parameterIndex, inputStream);
705++ }
706++
707++ public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException
708++ {
709++ getWrappedObject().setCharacterStream(parameterIndex, reader, length);
710++ }
711++
712++ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException
713++ {
714++ getWrappedObject().setCharacterStream(parameterIndex, reader);
715++ }
716++
717++ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException
718++ {
719++ getWrappedObject().setClob(parameterIndex, reader, length);
720++ }
721++
722++ public void setClob(int parameterIndex, Reader reader) throws SQLException
723++ {
724++ getWrappedObject().setClob(parameterIndex, reader);
725++ }
726++
727++ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException
728++ {
729++ getWrappedObject().setNCharacterStream(parameterIndex, value, length);
730++ }
731++
732++ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException
733++ {
734++ getWrappedObject().setNCharacterStream(parameterIndex, value);
735++ }
736++
737++ public void setNClob(int parameterIndex, NClob value) throws SQLException
738++ {
739++ getWrappedObject().setNClob(parameterIndex, value);
740++ }
741++
742++ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException
743++ {
744++ getWrappedObject().setNClob(parameterIndex, reader, length);
745++ }
746++
747++ public void setNClob(int parameterIndex, Reader reader) throws SQLException
748++ {
749++ getWrappedObject().setNClob(parameterIndex, reader);
750++ }
751++
752++ public void setNString(int parameterIndex, String value) throws SQLException
753++ {
754++ getWrappedObject().setNString(parameterIndex, value);
755++ }
756++
757++ public void setRowId(int parameterIndex, RowId x) throws SQLException
758++ {
759++ getWrappedObject().setRowId(parameterIndex, x);
760++ }
761++
762++ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException
763++ {
764++ getWrappedObject().setSQLXML(parameterIndex, xmlObject);
765++ }
766++
767++ public boolean isClosed() throws SQLException
768++ {
769++ return getWrappedObject().isClosed();
770++ }
771++
772++ public boolean isPoolable() throws SQLException
773++ {
774++ return getWrappedObject().isPoolable();
775++ }
776++
777++ public void setPoolable(boolean poolable) throws SQLException
778++ {
779++ getWrappedObject().setPoolable(poolable);
780++ }
781++
782++ public boolean isCloseOnCompletion() throws SQLException
783++ {
784++ return getWrappedObject().isCloseOnCompletion();
785++ }
786++
787++ public void closeOnCompletion() throws SQLException
788++ {
789++ getWrappedObject().closeOnCompletion();
790++ }
791++}
792+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedCallableStatementJDK7.java
793+===================================================================
794+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
795++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedCallableStatementJDK7.java 2012-07-30 23:03:12.764587908 -0300
796+@@ -0,0 +1,799 @@
797++/*
798++ * JBoss, Home of Professional Open Source.
799++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
800++ * as indicated by the @author tags. See the copyright.txt file in the
801++ * distribution for a full listing of individual contributors.
802++ *
803++ * This is free software; you can redistribute it and/or modify it
804++ * under the terms of the GNU Lesser General Public License as
805++ * published by the Free Software Foundation; either version 2.1 of
806++ * the License, or (at your option) any later version.
807++ *
808++ * This software is distributed in the hope that it will be useful,
809++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
810++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
811++ * Lesser General Public License for more details.
812++ *
813++ * You should have received a copy of the GNU Lesser General Public
814++ * License along with this software; if not, write to the Free
815++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
816++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
817++ */
818++package org.jboss.resource.adapter.jdbc.jdk7;
819++
820++import java.io.InputStream;
821++import java.io.Reader;
822++import java.sql.Blob;
823++import java.sql.CallableStatement;
824++import java.sql.Clob;
825++import java.sql.NClob;
826++import java.sql.PreparedStatement;
827++import java.sql.ResultSet;
828++import java.sql.RowId;
829++import java.sql.SQLException;
830++import java.sql.SQLXML;
831++
832++import org.jboss.resource.adapter.jdbc.WrappedCallableStatement;
833++import org.jboss.resource.adapter.jdbc.WrappedResultSet;
834++
835++/**
836++ * WrappedCallableStatementJDK7.
837++ *
838++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
839++ * @version $Revision: 1.1 $
840++ */
841++public class WrappedCallableStatementJDK7 extends WrappedCallableStatement
842++{
843++ public WrappedCallableStatementJDK7(WrappedConnectionJDK7 lc, CallableStatement s)
844++ {
845++ super(lc, s);
846++ }
847++
848++ protected WrappedResultSet wrapResultSet(ResultSet resultSet)
849++ {
850++ return new WrappedResultSetJDK7(this, resultSet);
851++ }
852++
853++ public boolean isClosed() throws SQLException
854++ {
855++ try
856++ {
857++ PreparedStatement wrapped = getWrappedObject();
858++ if (wrapped == null)
859++ return true;
860++ return wrapped.isClosed();
861++ }
862++ catch (Throwable t)
863++ {
864++ throw checkException(t);
865++ }
866++ }
867++
868++ public boolean isPoolable() throws SQLException
869++ {
870++ PreparedStatement statement = getUnderlyingStatement();
871++ try
872++ {
873++ return statement.isPoolable();
874++ }
875++ catch (Throwable t)
876++ {
877++ throw checkException(t);
878++ }
879++ }
880++
881++ public void setPoolable(boolean poolable) throws SQLException
882++ {
883++ PreparedStatement statement = getUnderlyingStatement();
884++ try
885++ {
886++ statement.setPoolable(poolable);
887++ }
888++ catch (Throwable t)
889++ {
890++ throw checkException(t);
891++ }
892++ }
893++
894++ public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException
895++ {
896++ PreparedStatement statement = getUnderlyingStatement();
897++ try
898++ {
899++ statement.setAsciiStream(parameterIndex, x, length);
900++ }
901++ catch (Throwable t)
902++ {
903++ throw checkException(t);
904++ }
905++ }
906++
907++ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException
908++ {
909++ PreparedStatement statement = getUnderlyingStatement();
910++ try
911++ {
912++ statement.setAsciiStream(parameterIndex, x);
913++ }
914++ catch (Throwable t)
915++ {
916++ throw checkException(t);
917++ }
918++ }
919++
920++ public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException
921++ {
922++ PreparedStatement statement = getUnderlyingStatement();
923++ try
924++ {
925++ statement.setBinaryStream(parameterIndex, x, length);
926++ }
927++ catch (Throwable t)
928++ {
929++ throw checkException(t);
930++ }
931++ }
932++
933++ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException
934++ {
935++ PreparedStatement statement = getUnderlyingStatement();
936++ try
937++ {
938++ statement.setBinaryStream(parameterIndex, x);
939++ }
940++ catch (Throwable t)
941++ {
942++ throw checkException(t);
943++ }
944++ }
945++
946++ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException
947++ {
948++ PreparedStatement statement = getUnderlyingStatement();
949++ try
950++ {
951++ statement.setBlob(parameterIndex, inputStream, length);
952++ }
953++ catch (Throwable t)
954++ {
955++ throw checkException(t);
956++ }
957++ }
958++
959++ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException
960++ {
961++ PreparedStatement statement = getUnderlyingStatement();
962++ try
963++ {
964++ statement.setBlob(parameterIndex, inputStream);
965++ }
966++ catch (Throwable t)
967++ {
968++ throw checkException(t);
969++ }
970++ }
971++
972++ public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException
973++ {
974++ PreparedStatement statement = getUnderlyingStatement();
975++ try
976++ {
977++ statement.setCharacterStream(parameterIndex, reader, length);
978++ }
979++ catch (Throwable t)
980++ {
981++ throw checkException(t);
982++ }
983++ }
984++
985++ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException
986++ {
987++ PreparedStatement statement = getUnderlyingStatement();
988++ try
989++ {
990++ statement.setCharacterStream(parameterIndex, reader);
991++ }
992++ catch (Throwable t)
993++ {
994++ throw checkException(t);
995++ }
996++ }
997++
998++ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException
999++ {
1000++ PreparedStatement statement = getUnderlyingStatement();
1001++ try
1002++ {
1003++ statement.setClob(parameterIndex, reader, length);
1004++ }
1005++ catch (Throwable t)
1006++ {
1007++ throw checkException(t);
1008++ }
1009++ }
1010++
1011++ public void setClob(int parameterIndex, Reader reader) throws SQLException
1012++ {
1013++ PreparedStatement statement = getUnderlyingStatement();
1014++ try
1015++ {
1016++ statement.setClob(parameterIndex, reader);
1017++ }
1018++ catch (Throwable t)
1019++ {
1020++ throw checkException(t);
1021++ }
1022++ }
1023++
1024++ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException
1025++ {
1026++ PreparedStatement statement = getUnderlyingStatement();
1027++ try
1028++ {
1029++ statement.setNCharacterStream(parameterIndex, value, length);
1030++ }
1031++ catch (Throwable t)
1032++ {
1033++ throw checkException(t);
1034++ }
1035++ }
1036++
1037++ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException
1038++ {
1039++ PreparedStatement statement = getUnderlyingStatement();
1040++ try
1041++ {
1042++ statement.setNCharacterStream(parameterIndex, value);
1043++ }
1044++ catch (Throwable t)
1045++ {
1046++ throw checkException(t);
1047++ }
1048++ }
1049++
1050++ public void setNClob(int parameterIndex, NClob value) throws SQLException
1051++ {
1052++ PreparedStatement statement = getUnderlyingStatement();
1053++ try
1054++ {
1055++ statement.setNClob(parameterIndex, value);
1056++ }
1057++ catch (Throwable t)
1058++ {
1059++ throw checkException(t);
1060++ }
1061++ }
1062++
1063++ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException
1064++ {
1065++ PreparedStatement statement = getUnderlyingStatement();
1066++ try
1067++ {
1068++ statement.setNClob(parameterIndex, reader, length);
1069++ }
1070++ catch (Throwable t)
1071++ {
1072++ throw checkException(t);
1073++ }
1074++ }
1075++
1076++ public void setNClob(int parameterIndex, Reader reader) throws SQLException
1077++ {
1078++ PreparedStatement statement = getUnderlyingStatement();
1079++ try
1080++ {
1081++ statement.setNClob(parameterIndex, reader);
1082++ }
1083++ catch (Throwable t)
1084++ {
1085++ throw checkException(t);
1086++ }
1087++ }
1088++
1089++ public void setNString(int parameterIndex, String value) throws SQLException
1090++ {
1091++ PreparedStatement statement = getUnderlyingStatement();
1092++ try
1093++ {
1094++ statement.setNString(parameterIndex, value);
1095++ }
1096++ catch (Throwable t)
1097++ {
1098++ throw checkException(t);
1099++ }
1100++ }
1101++
1102++ public void setRowId(int parameterIndex, RowId x) throws SQLException
1103++ {
1104++ PreparedStatement statement = getUnderlyingStatement();
1105++ try
1106++ {
1107++ statement.setRowId(parameterIndex, x);
1108++ }
1109++ catch (Throwable t)
1110++ {
1111++ throw checkException(t);
1112++ }
1113++ }
1114++
1115++ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException
1116++ {
1117++ PreparedStatement statement = getUnderlyingStatement();
1118++ try
1119++ {
1120++ statement.setSQLXML(parameterIndex, xmlObject);
1121++ }
1122++ catch (Throwable t)
1123++ {
1124++ throw checkException(t);
1125++ }
1126++ }
1127++
1128++ public Reader getCharacterStream(int parameterIndex) throws SQLException
1129++ {
1130++ CallableStatement statement = getUnderlyingStatement();
1131++ try
1132++ {
1133++ return statement.getCharacterStream(parameterIndex);
1134++ }
1135++ catch (Throwable t)
1136++ {
1137++ throw checkException(t);
1138++ }
1139++ }
1140++
1141++ public Reader getCharacterStream(String parameterName) throws SQLException
1142++ {
1143++ CallableStatement statement = getUnderlyingStatement();
1144++ try
1145++ {
1146++ return statement.getCharacterStream(parameterName);
1147++ }
1148++ catch (Throwable t)
1149++ {
1150++ throw checkException(t);
1151++ }
1152++ }
1153++
1154++ public Reader getNCharacterStream(int parameterIndex) throws SQLException
1155++ {
1156++ CallableStatement statement = getUnderlyingStatement();
1157++ try
1158++ {
1159++ return statement.getNCharacterStream(parameterIndex);
1160++ }
1161++ catch (Throwable t)
1162++ {
1163++ throw checkException(t);
1164++ }
1165++ }
1166++
1167++ public Reader getNCharacterStream(String parameterName) throws SQLException
1168++ {
1169++ CallableStatement statement = getUnderlyingStatement();
1170++ try
1171++ {
1172++ return statement.getCharacterStream(parameterName);
1173++ }
1174++ catch (Throwable t)
1175++ {
1176++ throw checkException(t);
1177++ }
1178++ }
1179++
1180++ public NClob getNClob(int parameterIndex) throws SQLException
1181++ {
1182++ CallableStatement statement = getUnderlyingStatement();
1183++ try
1184++ {
1185++ return statement.getNClob(parameterIndex);
1186++ }
1187++ catch (Throwable t)
1188++ {
1189++ throw checkException(t);
1190++ }
1191++ }
1192++
1193++ public NClob getNClob(String parameterName) throws SQLException
1194++ {
1195++ CallableStatement statement = getUnderlyingStatement();
1196++ try
1197++ {
1198++ return statement.getNClob(parameterName);
1199++ }
1200++ catch (Throwable t)
1201++ {
1202++ throw checkException(t);
1203++ }
1204++ }
1205++
1206++ public String getNString(int parameterIndex) throws SQLException
1207++ {
1208++ CallableStatement statement = getUnderlyingStatement();
1209++ try
1210++ {
1211++ return statement.getNString(parameterIndex);
1212++ }
1213++ catch (Throwable t)
1214++ {
1215++ throw checkException(t);
1216++ }
1217++ }
1218++
1219++ public String getNString(String parameterName) throws SQLException
1220++ {
1221++ CallableStatement statement = getUnderlyingStatement();
1222++ try
1223++ {
1224++ return statement.getNString(parameterName);
1225++ }
1226++ catch (Throwable t)
1227++ {
1228++ throw checkException(t);
1229++ }
1230++ }
1231++
1232++ public RowId getRowId(int parameterIndex) throws SQLException
1233++ {
1234++ CallableStatement statement = getUnderlyingStatement();
1235++ try
1236++ {
1237++ return statement.getRowId(parameterIndex);
1238++ }
1239++ catch (Throwable t)
1240++ {
1241++ throw checkException(t);
1242++ }
1243++ }
1244++
1245++ public RowId getRowId(String parameterName) throws SQLException
1246++ {
1247++ CallableStatement statement = getUnderlyingStatement();
1248++ try
1249++ {
1250++ return statement.getRowId(parameterName);
1251++ }
1252++ catch (Throwable t)
1253++ {
1254++ throw checkException(t);
1255++ }
1256++ }
1257++
1258++ public SQLXML getSQLXML(int parameterIndex) throws SQLException
1259++ {
1260++ CallableStatement statement = getUnderlyingStatement();
1261++ try
1262++ {
1263++ return statement.getSQLXML(parameterIndex);
1264++ }
1265++ catch (Throwable t)
1266++ {
1267++ throw checkException(t);
1268++ }
1269++ }
1270++
1271++ public SQLXML getSQLXML(String parameterName) throws SQLException
1272++ {
1273++ CallableStatement statement = getUnderlyingStatement();
1274++ try
1275++ {
1276++ return statement.getSQLXML(parameterName);
1277++ }
1278++ catch (Throwable t)
1279++ {
1280++ throw checkException(t);
1281++ }
1282++ }
1283++
1284++ public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException
1285++ {
1286++ CallableStatement statement = getUnderlyingStatement();
1287++ try
1288++ {
1289++ statement.setAsciiStream(parameterName, x, length);
1290++ }
1291++ catch (Throwable t)
1292++ {
1293++ throw checkException(t);
1294++ }
1295++ }
1296++
1297++ public void setAsciiStream(String parameterName, InputStream x) throws SQLException
1298++ {
1299++ CallableStatement statement = getUnderlyingStatement();
1300++ try
1301++ {
1302++ statement.setAsciiStream(parameterName, x);
1303++ }
1304++ catch (Throwable t)
1305++ {
1306++ throw checkException(t);
1307++ }
1308++ }
1309++
1310++ public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException
1311++ {
1312++ CallableStatement statement = getUnderlyingStatement();
1313++ try
1314++ {
1315++ statement.setBinaryStream(parameterName, x, length);
1316++ }
1317++ catch (Throwable t)
1318++ {
1319++ throw checkException(t);
1320++ }
1321++ }
1322++
1323++ public void setBinaryStream(String parameterName, InputStream x) throws SQLException
1324++ {
1325++ CallableStatement statement = getUnderlyingStatement();
1326++ try
1327++ {
1328++ statement.setBinaryStream(parameterName, x);
1329++ }
1330++ catch (Throwable t)
1331++ {
1332++ throw checkException(t);
1333++ }
1334++ }
1335++
1336++ public void setBlob(String parameterName, Blob x) throws SQLException
1337++ {
1338++ CallableStatement statement = getUnderlyingStatement();
1339++ try
1340++ {
1341++ statement.setBlob(parameterName, x);
1342++ }
1343++ catch (Throwable t)
1344++ {
1345++ throw checkException(t);
1346++ }
1347++ }
1348++
1349++ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException
1350++ {
1351++ CallableStatement statement = getUnderlyingStatement();
1352++ try
1353++ {
1354++ statement.setBlob(parameterName, inputStream, length);
1355++ }
1356++ catch (Throwable t)
1357++ {
1358++ throw checkException(t);
1359++ }
1360++ }
1361++
1362++ public void setBlob(String parameterName, InputStream inputStream) throws SQLException
1363++ {
1364++ CallableStatement statement = getUnderlyingStatement();
1365++ try
1366++ {
1367++ statement.setBlob(parameterName, inputStream);
1368++ }
1369++ catch (Throwable t)
1370++ {
1371++ throw checkException(t);
1372++ }
1373++ }
1374++
1375++ public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException
1376++ {
1377++ CallableStatement statement = getUnderlyingStatement();
1378++ try
1379++ {
1380++ statement.setCharacterStream(parameterName, reader, length);
1381++ }
1382++ catch (Throwable t)
1383++ {
1384++ throw checkException(t);
1385++ }
1386++ }
1387++
1388++ public void setCharacterStream(String parameterName, Reader reader) throws SQLException
1389++ {
1390++ CallableStatement statement = getUnderlyingStatement();
1391++ try
1392++ {
1393++ statement.setCharacterStream(parameterName, reader);
1394++ }
1395++ catch (Throwable t)
1396++ {
1397++ throw checkException(t);
1398++ }
1399++ }
1400++
1401++ public void setClob(String parameterName, Clob x) throws SQLException
1402++ {
1403++ CallableStatement statement = getUnderlyingStatement();
1404++ try
1405++ {
1406++ statement.setClob(parameterName, x);
1407++ }
1408++ catch (Throwable t)
1409++ {
1410++ throw checkException(t);
1411++ }
1412++ }
1413++
1414++ public void setClob(String parameterName, Reader reader, long length) throws SQLException
1415++ {
1416++ CallableStatement statement = getUnderlyingStatement();
1417++ try
1418++ {
1419++ statement.setClob(parameterName, reader, length);
1420++ }
1421++ catch (Throwable t)
1422++ {
1423++ throw checkException(t);
1424++ }
1425++ }
1426++
1427++ public void setClob(String parameterName, Reader reader) throws SQLException
1428++ {
1429++ CallableStatement statement = getUnderlyingStatement();
1430++ try
1431++ {
1432++ statement.setClob(parameterName, reader);
1433++ }
1434++ catch (Throwable t)
1435++ {
1436++ throw checkException(t);
1437++ }
1438++ }
1439++
1440++ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException
1441++ {
1442++ CallableStatement statement = getUnderlyingStatement();
1443++ try
1444++ {
1445++ statement.setNCharacterStream(parameterName, value, length);
1446++ }
1447++ catch (Throwable t)
1448++ {
1449++ throw checkException(t);
1450++ }
1451++ }
1452++
1453++ public void setNCharacterStream(String parameterName, Reader value) throws SQLException
1454++ {
1455++ CallableStatement statement = getUnderlyingStatement();
1456++ try
1457++ {
1458++ statement.setNCharacterStream(parameterName, value);
1459++ }
1460++ catch (Throwable t)
1461++ {
1462++ throw checkException(t);
1463++ }
1464++ }
1465++
1466++ public void setNClob(String parameterName, NClob value) throws SQLException
1467++ {
1468++ CallableStatement statement = getUnderlyingStatement();
1469++ try
1470++ {
1471++ statement.setNClob(parameterName, value);
1472++ }
1473++ catch (Throwable t)
1474++ {
1475++ throw checkException(t);
1476++ }
1477++ }
1478++
1479++ public void setNClob(String parameterName, Reader reader, long length) throws SQLException
1480++ {
1481++ CallableStatement statement = getUnderlyingStatement();
1482++ try
1483++ {
1484++ statement.setNClob(parameterName, reader, length);
1485++ }
1486++ catch (Throwable t)
1487++ {
1488++ throw checkException(t);
1489++ }
1490++ }
1491++
1492++ public void setNClob(String parameterName, Reader reader) throws SQLException
1493++ {
1494++ CallableStatement statement = getUnderlyingStatement();
1495++ try
1496++ {
1497++ statement.setNClob(parameterName, reader);
1498++ }
1499++ catch (Throwable t)
1500++ {
1501++ throw checkException(t);
1502++ }
1503++ }
1504++
1505++ public void setNString(String parameterName, String value) throws SQLException
1506++ {
1507++ CallableStatement statement = getUnderlyingStatement();
1508++ try
1509++ {
1510++ statement.setNString(parameterName, value);
1511++ }
1512++ catch (Throwable t)
1513++ {
1514++ throw checkException(t);
1515++ }
1516++ }
1517++
1518++ public void setRowId(String parameterName, RowId x) throws SQLException
1519++ {
1520++ CallableStatement statement = getUnderlyingStatement();
1521++ try
1522++ {
1523++ statement.setRowId(parameterName, x);
1524++ }
1525++ catch (Throwable t)
1526++ {
1527++ throw checkException(t);
1528++ }
1529++ }
1530++
1531++ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException
1532++ {
1533++ CallableStatement statement = getUnderlyingStatement();
1534++ try
1535++ {
1536++ statement.setSQLXML(parameterName, xmlObject);
1537++ }
1538++ catch (Throwable t)
1539++ {
1540++ throw checkException(t);
1541++ }
1542++ }
1543++
1544++ public boolean isCloseOnCompletion() throws SQLException
1545++ {
1546++ CallableStatement statement = getUnderlyingStatement();
1547++ try
1548++ {
1549++ return statement.isCloseOnCompletion();
1550++ }
1551++ catch (Throwable t)
1552++ {
1553++ throw checkException(t);
1554++ }
1555++ }
1556++
1557++ public void closeOnCompletion() throws SQLException
1558++ {
1559++ CallableStatement statement = getUnderlyingStatement();
1560++ try
1561++ {
1562++ statement.closeOnCompletion();
1563++ }
1564++ catch (Throwable t)
1565++ {
1566++ throw checkException(t);
1567++ }
1568++ }
1569++
1570++ public <T> T getObject(String parameterName, Class<T> type) throws SQLException
1571++ {
1572++ CallableStatement statement = getUnderlyingStatement();
1573++ try
1574++ {
1575++ return statement.getObject(parameterName, type);
1576++ }
1577++ catch (Throwable t)
1578++ {
1579++ throw checkException(t);
1580++ }
1581++ }
1582++
1583++ public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException
1584++ {
1585++ CallableStatement statement = getUnderlyingStatement();
1586++ try
1587++ {
1588++ return statement.getObject(parameterIndex, type);
1589++ }
1590++ catch (Throwable t)
1591++ {
1592++ throw checkException(t);
1593++ }
1594++ }
1595++}
1596+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedConnectionFactoryJDK7.java
1597+===================================================================
1598+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
1599++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedConnectionFactoryJDK7.java 2012-07-25 16:36:54.472131488 -0300
1600+@@ -0,0 +1,56 @@
1601++/*
1602++ * JBoss, Home of Professional Open Source.
1603++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
1604++ * as indicated by the @author tags. See the copyright.txt file in the
1605++ * distribution for a full listing of individual contributors.
1606++ *
1607++ * This is free software; you can redistribute it and/or modify it
1608++ * under the terms of the GNU Lesser General Public License as
1609++ * published by the Free Software Foundation; either version 2.1 of
1610++ * the License, or (at your option) any later version.
1611++ *
1612++ * This software is distributed in the hope that it will be useful,
1613++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
1614++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1615++ * Lesser General Public License for more details.
1616++ *
1617++ * You should have received a copy of the GNU Lesser General Public
1618++ * License along with this software; if not, write to the Free
1619++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1620++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
1621++ */
1622++package org.jboss.resource.adapter.jdbc.jdk7;
1623++
1624++import java.sql.CallableStatement;
1625++import java.sql.PreparedStatement;
1626++import java.sql.SQLException;
1627++
1628++import org.jboss.resource.adapter.jdbc.BaseWrapperManagedConnection;
1629++import org.jboss.resource.adapter.jdbc.CachedCallableStatement;
1630++import org.jboss.resource.adapter.jdbc.CachedPreparedStatement;
1631++import org.jboss.resource.adapter.jdbc.WrappedConnection;
1632++import org.jboss.resource.adapter.jdbc.WrappedConnectionFactory;
1633++
1634++/**
1635++ * WrappedConnectionFactoryJDK7
1636++ *
1637++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
1638++ * @version $Revision: 1.1 $
1639++ */
1640++public class WrappedConnectionFactoryJDK7 implements WrappedConnectionFactory
1641++{
1642++ public WrappedConnection createWrappedConnection(BaseWrapperManagedConnection mc)
1643++ {
1644++ return new WrappedConnectionJDK7(mc);
1645++ }
1646++
1647++ public CachedPreparedStatement createCachedPreparedStatement(PreparedStatement ps) throws SQLException
1648++ {
1649++ return new CachedPreparedStatementJDK7(ps);
1650++ }
1651++
1652++ public CachedCallableStatement createCachedCallableStatement(CallableStatement cs) throws SQLException
1653++ {
1654++ return new CachedCallableStatementJDK7(cs);
1655++ }
1656++}
1657+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedConnectionJDK7.java
1658+===================================================================
1659+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
1660++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedConnectionJDK7.java 2012-07-30 23:05:14.257190359 -0300
1661+@@ -0,0 +1,455 @@
1662++/*
1663++ * JBoss, Home of Professional Open Source.
1664++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
1665++ * as indicated by the @author tags. See the copyright.txt file in the
1666++ * distribution for a full listing of individual contributors.
1667++ *
1668++ * This is free software; you can redistribute it and/or modify it
1669++ * under the terms of the GNU Lesser General Public License as
1670++ * published by the Free Software Foundation; either version 2.1 of
1671++ * the License, or (at your option) any later version.
1672++ *
1673++ * This software is distributed in the hope that it will be useful,
1674++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
1675++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1676++ * Lesser General Public License for more details.
1677++ *
1678++ * You should have received a copy of the GNU Lesser General Public
1679++ * License along with this software; if not, write to the Free
1680++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1681++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
1682++ */
1683++package org.jboss.resource.adapter.jdbc.jdk7;
1684++
1685++import java.sql.Array;
1686++import java.sql.Blob;
1687++import java.sql.CallableStatement;
1688++import java.sql.Clob;
1689++import java.sql.Connection;
1690++import java.sql.NClob;
1691++import java.sql.PreparedStatement;
1692++import java.sql.SQLClientInfoException;
1693++import java.sql.SQLException;
1694++import java.sql.SQLXML;
1695++import java.sql.Statement;
1696++import java.sql.Struct;
1697++import java.util.Properties;
1698++import java.util.concurrent.Executor;
1699++
1700++import org.jboss.resource.adapter.jdbc.BaseWrapperManagedConnection;
1701++import org.jboss.resource.adapter.jdbc.WrappedCallableStatement;
1702++import org.jboss.resource.adapter.jdbc.WrappedConnection;
1703++import org.jboss.resource.adapter.jdbc.WrappedPreparedStatement;
1704++import org.jboss.resource.adapter.jdbc.WrappedStatement;
1705++
1706++/**
1707++ * WrappedConnectionJDK6.
1708++ *
1709++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
1710++ * @version $Revision: 1.1 $
1711++ */
1712++@SuppressWarnings("unchecked")
1713++public class WrappedConnectionJDK7 extends WrappedConnection
1714++{
1715++ /**
1716++ * Create a new WrappedConnectionJDK6.
1717++ *
1718++ * @param mc the managed connection
1719++ */
1720++ public WrappedConnectionJDK7(BaseWrapperManagedConnection mc)
1721++ {
1722++ super(mc);
1723++ }
1724++
1725++ protected WrappedStatement wrapStatement(Statement statement)
1726++ {
1727++ return new WrappedStatementJDK7(this, statement);
1728++ }
1729++
1730++ protected WrappedPreparedStatement wrapPreparedStatement(PreparedStatement statement)
1731++ {
1732++ return new WrappedPreparedStatementJDK7(this, statement);
1733++ }
1734++
1735++ protected WrappedCallableStatement wrapCallableStatement(CallableStatement statement)
1736++ {
1737++ return new WrappedCallableStatementJDK7(this, statement);
1738++ }
1739++
1740++ public Array createArrayOf(String typeName, Object[] elements) throws SQLException
1741++ {
1742++ lock();
1743++ try
1744++ {
1745++ Connection c = getUnderlyingConnection();
1746++ try
1747++ {
1748++ return c.createArrayOf(typeName, elements);
1749++ }
1750++ catch (Throwable t)
1751++ {
1752++ throw checkException(t);
1753++ }
1754++ }
1755++ finally
1756++ {
1757++ unlock();
1758++ }
1759++ }
1760++
1761++ public Blob createBlob() throws SQLException
1762++ {
1763++ lock();
1764++ try
1765++ {
1766++ Connection c = getUnderlyingConnection();
1767++ try
1768++ {
1769++ return c.createBlob();
1770++ }
1771++ catch (Throwable t)
1772++ {
1773++ throw checkException(t);
1774++ }
1775++ }
1776++ finally
1777++ {
1778++ unlock();
1779++ }
1780++ }
1781++
1782++ public Clob createClob() throws SQLException
1783++ {
1784++ lock();
1785++ try
1786++ {
1787++ Connection c = getUnderlyingConnection();
1788++ try
1789++ {
1790++ return c.createClob();
1791++ }
1792++ catch (Throwable t)
1793++ {
1794++ throw checkException(t);
1795++ }
1796++ }
1797++ finally
1798++ {
1799++ unlock();
1800++ }
1801++ }
1802++
1803++ public NClob createNClob() throws SQLException
1804++ {
1805++ lock();
1806++ try
1807++ {
1808++ Connection c = getUnderlyingConnection();
1809++ try
1810++ {
1811++ return c.createNClob();
1812++ }
1813++ catch (Throwable t)
1814++ {
1815++ throw checkException(t);
1816++ }
1817++ }
1818++ finally
1819++ {
1820++ unlock();
1821++ }
1822++ }
1823++
1824++ public SQLXML createSQLXML() throws SQLException
1825++ {
1826++ lock();
1827++ try
1828++ {
1829++ Connection c = getUnderlyingConnection();
1830++ try
1831++ {
1832++ return c.createSQLXML();
1833++ }
1834++ catch (Throwable t)
1835++ {
1836++ throw checkException(t);
1837++ }
1838++ }
1839++ finally
1840++ {
1841++ unlock();
1842++ }
1843++ }
1844++
1845++ public Struct createStruct(String typeName, Object[] attributes) throws SQLException
1846++ {
1847++ lock();
1848++ try
1849++ {
1850++ Connection c = getUnderlyingConnection();
1851++ try
1852++ {
1853++ return c.createStruct(typeName, attributes);
1854++ }
1855++ catch (Throwable t)
1856++ {
1857++ throw checkException(t);
1858++ }
1859++ }
1860++ finally
1861++ {
1862++ unlock();
1863++ }
1864++ }
1865++
1866++ public Properties getClientInfo() throws SQLException
1867++ {
1868++ lock();
1869++ try
1870++ {
1871++ Connection c = getUnderlyingConnection();
1872++ try
1873++ {
1874++ return c.getClientInfo();
1875++ }
1876++ catch (Throwable t)
1877++ {
1878++ throw checkException(t);
1879++ }
1880++ }
1881++ finally
1882++ {
1883++ unlock();
1884++ }
1885++ }
1886++
1887++ public String getClientInfo(String name) throws SQLException
1888++ {
1889++ lock();
1890++ try
1891++ {
1892++ Connection c = getUnderlyingConnection();
1893++ try
1894++ {
1895++ return c.getClientInfo(name);
1896++ }
1897++ catch (Throwable t)
1898++ {
1899++ throw checkException(t);
1900++ }
1901++ }
1902++ finally
1903++ {
1904++ unlock();
1905++ }
1906++ }
1907++
1908++ public boolean isValid(int timeout) throws SQLException
1909++ {
1910++ lock();
1911++ try
1912++ {
1913++ Connection c = getUnderlyingConnection();
1914++ try
1915++ {
1916++ return c.isValid(timeout);
1917++ }
1918++ catch (Throwable t)
1919++ {
1920++ throw checkException(t);
1921++ }
1922++ }
1923++ finally
1924++ {
1925++ unlock();
1926++ }
1927++ }
1928++
1929++ public void setClientInfo(Properties properties) throws SQLClientInfoException
1930++ {
1931++ try
1932++ {
1933++ lock();
1934++ try
1935++ {
1936++ Connection c = getUnderlyingConnection();
1937++ try
1938++ {
1939++ c.setClientInfo(properties);
1940++ }
1941++ catch (Throwable t)
1942++ {
1943++ throw checkException(t);
1944++ }
1945++ }
1946++ catch (SQLClientInfoException e)
1947++ {
1948++ throw e;
1949++ }
1950++ catch (SQLException e)
1951++ {
1952++ SQLClientInfoException t = new SQLClientInfoException();
1953++ t.initCause(e);
1954++ throw t;
1955++ }
1956++ }
1957++ catch (SQLException e)
1958++ {
1959++ SQLClientInfoException t = new SQLClientInfoException();
1960++ t.initCause(e);
1961++ throw t;
1962++ }
1963++ finally
1964++ {
1965++ unlock();
1966++ }
1967++ }
1968++
1969++ public void setClientInfo(String name, String value) throws SQLClientInfoException
1970++ {
1971++ try
1972++ {
1973++ lock();
1974++ try
1975++ {
1976++ Connection c = getUnderlyingConnection();
1977++ try
1978++ {
1979++ c.setClientInfo(name, value);
1980++ }
1981++ catch (Throwable t)
1982++ {
1983++ throw checkException(t);
1984++ }
1985++ }
1986++ catch (SQLClientInfoException e)
1987++ {
1988++ throw e;
1989++ }
1990++ catch (SQLException e)
1991++ {
1992++ SQLClientInfoException t = new SQLClientInfoException();
1993++ t.initCause(e);
1994++ throw t;
1995++ }
1996++ }
1997++ catch (SQLException e)
1998++ {
1999++ SQLClientInfoException t = new SQLClientInfoException();
2000++ t.initCause(e);
2001++ throw t;
2002++ }
2003++ finally
2004++ {
2005++ unlock();
2006++ }
2007++ }
2008++
2009++ /**
2010++ * {@inheritDoc}
2011++ */
2012++ public int getNetworkTimeout() throws SQLException
2013++ {
2014++ lock();
2015++ try
2016++ {
2017++ Connection c = getUnderlyingConnection();
2018++ try
2019++ {
2020++ return c.getNetworkTimeout();
2021++ }
2022++ catch (Throwable t)
2023++ {
2024++ throw checkException(t);
2025++ }
2026++ }
2027++ finally
2028++ {
2029++ unlock();
2030++ }
2031++ }
2032++
2033++ public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException
2034++ {
2035++ lock();
2036++ try
2037++ {
2038++ Connection c = getUnderlyingConnection();
2039++ try
2040++ {
2041++ c.setNetworkTimeout(executor, milliseconds);
2042++ }
2043++ catch (Throwable t)
2044++ {
2045++ throw checkException(t);
2046++ }
2047++ }
2048++ finally
2049++ {
2050++ unlock();
2051++ }
2052++ }
2053++
2054++ public void abort(Executor executor) throws SQLException
2055++ {
2056++ lock();
2057++ try
2058++ {
2059++ Connection c = getUnderlyingConnection();
2060++ try
2061++ {
2062++ c.abort(executor);
2063++ }
2064++ catch (Throwable t)
2065++ {
2066++ throw checkException(t);
2067++ }
2068++ }
2069++ finally
2070++ {
2071++ unlock();
2072++ }
2073++ }
2074++
2075++ public String getSchema() throws SQLException
2076++ {
2077++ lock();
2078++ try
2079++ {
2080++ Connection c = getUnderlyingConnection();
2081++ try
2082++ {
2083++ return c.getSchema();
2084++ }
2085++ catch (Throwable t)
2086++ {
2087++ throw checkException(t);
2088++ }
2089++ }
2090++ finally
2091++ {
2092++ unlock();
2093++ }
2094++ }
2095++
2096++ public void setSchema(String schema) throws SQLException
2097++ {
2098++ lock();
2099++ try
2100++ {
2101++ Connection c = getUnderlyingConnection();
2102++ try
2103++ {
2104++ c.setSchema(schema);
2105++ }
2106++ catch (Throwable t)
2107++ {
2108++ throw checkException(t);
2109++ }
2110++ }
2111++ finally
2112++ {
2113++ unlock();
2114++ }
2115++ }
2116++}
2117+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedPreparedStatementJDK7.java
2118+===================================================================
2119+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
2120++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedPreparedStatementJDK7.java 2012-07-30 20:12:49.661223581 -0300
2121+@@ -0,0 +1,535 @@
2122++/*
2123++ * JBoss, Home of Professional Open Source.
2124++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
2125++ * as indicated by the @author tags. See the copyright.txt file in the
2126++ * distribution for a full listing of individual contributors.
2127++ *
2128++ * This is free software; you can redistribute it and/or modify it
2129++ * under the terms of the GNU Lesser General Public License as
2130++ * published by the Free Software Foundation; either version 2.1 of
2131++ * the License, or (at your option) any later version.
2132++ *
2133++ * This software is distributed in the hope that it will be useful,
2134++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
2135++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2136++ * Lesser General Public License for more details.
2137++ *
2138++ * You should have received a copy of the GNU Lesser General Public
2139++ * License along with this software; if not, write to the Free
2140++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
2141++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
2142++ */
2143++package org.jboss.resource.adapter.jdbc.jdk7;
2144++
2145++import java.io.InputStream;
2146++import java.io.Reader;
2147++import java.sql.NClob;
2148++import java.sql.PreparedStatement;
2149++import java.sql.ResultSet;
2150++import java.sql.RowId;
2151++import java.sql.SQLException;
2152++import java.sql.SQLXML;
2153++
2154++import org.jboss.resource.adapter.jdbc.WrappedPreparedStatement;
2155++import org.jboss.resource.adapter.jdbc.WrappedResultSet;
2156++
2157++/**
2158++ * WrappedPreparedStatementJDK7.
2159++ *
2160++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
2161++ * @version $Revision: 1.1 $
2162++ */
2163++public class WrappedPreparedStatementJDK7 extends WrappedPreparedStatement
2164++{
2165++ public WrappedPreparedStatementJDK7(WrappedConnectionJDK7 lc, PreparedStatement s)
2166++ {
2167++ super(lc, s);
2168++ }
2169++
2170++ protected WrappedResultSet wrapResultSet(ResultSet resultSet)
2171++ {
2172++ return new WrappedResultSetJDK7(this, resultSet);
2173++ }
2174++
2175++ public boolean isClosed() throws SQLException
2176++ {
2177++ lock();
2178++ try
2179++ {
2180++ PreparedStatement wrapped = getWrappedObject();
2181++ if (wrapped == null)
2182++ return true;
2183++ return wrapped.isClosed();
2184++ }
2185++ catch (Throwable t)
2186++ {
2187++ throw checkException(t);
2188++ }
2189++ finally
2190++ {
2191++ unlock();
2192++ }
2193++ }
2194++
2195++ public boolean isPoolable() throws SQLException
2196++ {
2197++ lock();
2198++ try
2199++ {
2200++ PreparedStatement statement = getUnderlyingStatement();
2201++ try
2202++ {
2203++ return statement.isPoolable();
2204++ }
2205++ catch (Throwable t)
2206++ {
2207++ throw checkException(t);
2208++ }
2209++ }
2210++ finally
2211++ {
2212++ unlock();
2213++ }
2214++ }
2215++
2216++ public void setPoolable(boolean poolable) throws SQLException
2217++ {
2218++ lock();
2219++ try
2220++ {
2221++ PreparedStatement statement = getUnderlyingStatement();
2222++ try
2223++ {
2224++ statement.setPoolable(poolable);
2225++ }
2226++ catch (Throwable t)
2227++ {
2228++ throw checkException(t);
2229++ }
2230++ }
2231++ finally
2232++ {
2233++ unlock();
2234++ }
2235++ }
2236++
2237++ public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException
2238++ {
2239++ lock();
2240++ try
2241++ {
2242++ PreparedStatement statement = getUnderlyingStatement();
2243++ try
2244++ {
2245++ statement.setAsciiStream(parameterIndex, x, length);
2246++ }
2247++ catch (Throwable t)
2248++ {
2249++ throw checkException(t);
2250++ }
2251++ }
2252++ finally
2253++ {
2254++ unlock();
2255++ }
2256++ }
2257++
2258++ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException
2259++ {
2260++ lock();
2261++ try
2262++ {
2263++ PreparedStatement statement = getUnderlyingStatement();
2264++ try
2265++ {
2266++ statement.setAsciiStream(parameterIndex, x);
2267++ }
2268++ catch (Throwable t)
2269++ {
2270++ throw checkException(t);
2271++ }
2272++ }
2273++ finally
2274++ {
2275++ unlock();
2276++ }
2277++ }
2278++
2279++ public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException
2280++ {
2281++ lock();
2282++ try
2283++ {
2284++ PreparedStatement statement = getUnderlyingStatement();
2285++ try
2286++ {
2287++ statement.setBinaryStream(parameterIndex, x, length);
2288++ }
2289++ catch (Throwable t)
2290++ {
2291++ throw checkException(t);
2292++ }
2293++ }
2294++ finally
2295++ {
2296++ unlock();
2297++ }
2298++ }
2299++
2300++ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException
2301++ {
2302++ lock();
2303++ try
2304++ {
2305++ PreparedStatement statement = getUnderlyingStatement();
2306++ try
2307++ {
2308++ statement.setBinaryStream(parameterIndex, x);
2309++ }
2310++ catch (Throwable t)
2311++ {
2312++ throw checkException(t);
2313++ }
2314++ }
2315++ finally
2316++ {
2317++ unlock();
2318++ }
2319++ }
2320++
2321++ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException
2322++ {
2323++ lock();
2324++ try
2325++ {
2326++ PreparedStatement statement = getUnderlyingStatement();
2327++ try
2328++ {
2329++ statement.setBlob(parameterIndex, inputStream, length);
2330++ }
2331++ catch (Throwable t)
2332++ {
2333++ throw checkException(t);
2334++ }
2335++ }
2336++ finally
2337++ {
2338++ unlock();
2339++ }
2340++ }
2341++
2342++ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException
2343++ {
2344++ lock();
2345++ try
2346++ {
2347++ PreparedStatement statement = getUnderlyingStatement();
2348++ try
2349++ {
2350++ statement.setBlob(parameterIndex, inputStream);
2351++ }
2352++ catch (Throwable t)
2353++ {
2354++ throw checkException(t);
2355++ }
2356++ }
2357++ finally
2358++ {
2359++ unlock();
2360++ }
2361++ }
2362++
2363++ public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException
2364++ {
2365++ lock();
2366++ try
2367++ {
2368++ PreparedStatement statement = getUnderlyingStatement();
2369++ try
2370++ {
2371++ statement.setCharacterStream(parameterIndex, reader, length);
2372++ }
2373++ catch (Throwable t)
2374++ {
2375++ throw checkException(t);
2376++ }
2377++ }
2378++ finally
2379++ {
2380++ unlock();
2381++ }
2382++ }
2383++
2384++ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException
2385++ {
2386++ lock();
2387++ try
2388++ {
2389++ PreparedStatement statement = getUnderlyingStatement();
2390++ try
2391++ {
2392++ statement.setCharacterStream(parameterIndex, reader);
2393++ }
2394++ catch (Throwable t)
2395++ {
2396++ throw checkException(t);
2397++ }
2398++ }
2399++ finally
2400++ {
2401++ unlock();
2402++ }
2403++ }
2404++
2405++ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException
2406++ {
2407++ lock();
2408++ try
2409++ {
2410++ PreparedStatement statement = getUnderlyingStatement();
2411++ try
2412++ {
2413++ statement.setClob(parameterIndex, reader, length);
2414++ }
2415++ catch (Throwable t)
2416++ {
2417++ throw checkException(t);
2418++ }
2419++ }
2420++ finally
2421++ {
2422++ unlock();
2423++ }
2424++ }
2425++
2426++ public void setClob(int parameterIndex, Reader reader) throws SQLException
2427++ {
2428++ lock();
2429++ try
2430++ {
2431++ PreparedStatement statement = getUnderlyingStatement();
2432++ try
2433++ {
2434++ statement.setClob(parameterIndex, reader);
2435++ }
2436++ catch (Throwable t)
2437++ {
2438++ throw checkException(t);
2439++ }
2440++ }
2441++ finally
2442++ {
2443++ unlock();
2444++ }
2445++ }
2446++
2447++ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException
2448++ {
2449++ lock();
2450++ try
2451++ {
2452++ PreparedStatement statement = getUnderlyingStatement();
2453++ try
2454++ {
2455++ statement.setNCharacterStream(parameterIndex, value, length);
2456++ }
2457++ catch (Throwable t)
2458++ {
2459++ throw checkException(t);
2460++ }
2461++ }
2462++ finally
2463++ {
2464++ unlock();
2465++ }
2466++ }
2467++
2468++ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException
2469++ {
2470++ lock();
2471++ try
2472++ {
2473++ PreparedStatement statement = getUnderlyingStatement();
2474++ try
2475++ {
2476++ statement.setNCharacterStream(parameterIndex, value);
2477++ }
2478++ catch (Throwable t)
2479++ {
2480++ throw checkException(t);
2481++ }
2482++ }
2483++ finally
2484++ {
2485++ unlock();
2486++ }
2487++ }
2488++
2489++ public void setNClob(int parameterIndex, NClob value) throws SQLException
2490++ {
2491++ lock();
2492++ try
2493++ {
2494++ PreparedStatement statement = getUnderlyingStatement();
2495++ try
2496++ {
2497++ statement.setNClob(parameterIndex, value);
2498++ }
2499++ catch (Throwable t)
2500++ {
2501++ throw checkException(t);
2502++ }
2503++ }
2504++ finally
2505++ {
2506++ unlock();
2507++ }
2508++ }
2509++
2510++ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException
2511++ {
2512++ lock();
2513++ try
2514++ {
2515++ PreparedStatement statement = getUnderlyingStatement();
2516++ try
2517++ {
2518++ statement.setNClob(parameterIndex, reader, length);
2519++ }
2520++ catch (Throwable t)
2521++ {
2522++ throw checkException(t);
2523++ }
2524++ }
2525++ finally
2526++ {
2527++ unlock();
2528++ }
2529++ }
2530++
2531++ public void setNClob(int parameterIndex, Reader reader) throws SQLException
2532++ {
2533++ lock();
2534++ try
2535++ {
2536++ PreparedStatement statement = getUnderlyingStatement();
2537++ try
2538++ {
2539++ statement.setNClob(parameterIndex, reader);
2540++ }
2541++ catch (Throwable t)
2542++ {
2543++ throw checkException(t);
2544++ }
2545++ }
2546++ finally
2547++ {
2548++ unlock();
2549++ }
2550++ }
2551++
2552++ public void setNString(int parameterIndex, String value) throws SQLException
2553++ {
2554++ lock();
2555++ try
2556++ {
2557++ PreparedStatement statement = getUnderlyingStatement();
2558++ try
2559++ {
2560++ statement.setNString(parameterIndex, value);
2561++ }
2562++ catch (Throwable t)
2563++ {
2564++ throw checkException(t);
2565++ }
2566++ }
2567++ finally
2568++ {
2569++ unlock();
2570++ }
2571++ }
2572++
2573++ public void setRowId(int parameterIndex, RowId x) throws SQLException
2574++ {
2575++ lock();
2576++ try
2577++ {
2578++ PreparedStatement statement = getUnderlyingStatement();
2579++ try
2580++ {
2581++ statement.setRowId(parameterIndex, x);
2582++ }
2583++ catch (Throwable t)
2584++ {
2585++ throw checkException(t);
2586++ }
2587++ }
2588++ finally
2589++ {
2590++ unlock();
2591++ }
2592++ }
2593++
2594++ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException
2595++ {
2596++ lock();
2597++ try
2598++ {
2599++ PreparedStatement statement = getUnderlyingStatement();
2600++ try
2601++ {
2602++ statement.setSQLXML(parameterIndex, xmlObject);
2603++ }
2604++ catch (Throwable t)
2605++ {
2606++ throw checkException(t);
2607++ }
2608++ }
2609++ finally
2610++ {
2611++ unlock();
2612++ }
2613++ }
2614++
2615++ public boolean isCloseOnCompletion() throws SQLException
2616++ {
2617++ lock();
2618++ try
2619++ {
2620++ PreparedStatement statement = getUnderlyingStatement();
2621++ try
2622++ {
2623++ return statement.isCloseOnCompletion();
2624++ }
2625++ catch (Throwable t)
2626++ {
2627++ throw checkException(t);
2628++ }
2629++ }
2630++ finally
2631++ {
2632++ unlock();
2633++ }
2634++ }
2635++
2636++ public void closeOnCompletion() throws SQLException
2637++ {
2638++ lock();
2639++ try
2640++ {
2641++ PreparedStatement statement = getUnderlyingStatement();
2642++ try
2643++ {
2644++ statement.closeOnCompletion();
2645++ }
2646++ catch (Throwable t)
2647++ {
2648++ throw checkException(t);
2649++ }
2650++ }
2651++ finally
2652++ {
2653++ unlock();
2654++ }
2655++ }
2656++}
2657+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedResultSetJDK7.java
2658+===================================================================
2659+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
2660++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedResultSetJDK7.java 2012-07-30 20:15:15.781948142 -0300
2661+@@ -0,0 +1,699 @@
2662++/*
2663++ * JBoss, Home of Professional Open Source.
2664++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
2665++ * as indicated by the @author tags. See the copyright.txt file in the
2666++ * distribution for a full listing of individual contributors.
2667++ *
2668++ * This is free software; you can redistribute it and/or modify it
2669++ * under the terms of the GNU Lesser General Public License as
2670++ * published by the Free Software Foundation; either version 2.1 of
2671++ * the License, or (at your option) any later version.
2672++ *
2673++ * This software is distributed in the hope that it will be useful,
2674++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
2675++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2676++ * Lesser General Public License for more details.
2677++ *
2678++ * You should have received a copy of the GNU Lesser General Public
2679++ * License along with this software; if not, write to the Free
2680++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
2681++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
2682++ */
2683++package org.jboss.resource.adapter.jdbc.jdk7;
2684++
2685++import java.io.InputStream;
2686++import java.io.Reader;
2687++import java.sql.NClob;
2688++import java.sql.ResultSet;
2689++import java.sql.RowId;
2690++import java.sql.SQLException;
2691++import java.sql.SQLXML;
2692++
2693++import org.jboss.resource.adapter.jdbc.WrappedResultSet;
2694++import org.jboss.resource.adapter.jdbc.WrappedStatement;
2695++
2696++/**
2697++ * WrappedResultSetJDK7.
2698++ *
2699++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
2700++ * @version $Revision: 1.1 $
2701++ */
2702++public class WrappedResultSetJDK7 extends WrappedResultSet
2703++{
2704++ public WrappedResultSetJDK7(WrappedStatement statement, ResultSet resultSet)
2705++ {
2706++ super(statement, resultSet);
2707++ }
2708++
2709++ public int getHoldability() throws SQLException
2710++ {
2711++ ResultSet resultSet = getUnderlyingResultSet();
2712++ try
2713++ {
2714++ return resultSet.getHoldability();
2715++ }
2716++ catch (Throwable t)
2717++ {
2718++ throw checkException(t);
2719++ }
2720++ }
2721++
2722++ public Reader getNCharacterStream(int columnIndex) throws SQLException
2723++ {
2724++ ResultSet resultSet = getUnderlyingResultSet();
2725++ try
2726++ {
2727++ return resultSet.getNCharacterStream(columnIndex);
2728++ }
2729++ catch (Throwable t)
2730++ {
2731++ throw checkException(t);
2732++ }
2733++ }
2734++
2735++ public Reader getNCharacterStream(String columnLabel) throws SQLException
2736++ {
2737++ ResultSet resultSet = getUnderlyingResultSet();
2738++ try
2739++ {
2740++ return resultSet.getNCharacterStream(columnLabel);
2741++ }
2742++ catch (Throwable t)
2743++ {
2744++ throw checkException(t);
2745++ }
2746++ }
2747++
2748++ public NClob getNClob(int columnIndex) throws SQLException
2749++ {
2750++ ResultSet resultSet = getUnderlyingResultSet();
2751++ try
2752++ {
2753++ return resultSet.getNClob(columnIndex);
2754++ }
2755++ catch (Throwable t)
2756++ {
2757++ throw checkException(t);
2758++ }
2759++ }
2760++
2761++ public NClob getNClob(String columnLabel) throws SQLException
2762++ {
2763++ ResultSet resultSet = getUnderlyingResultSet();
2764++ try
2765++ {
2766++ return resultSet.getNClob(columnLabel);
2767++ }
2768++ catch (Throwable t)
2769++ {
2770++ throw checkException(t);
2771++ }
2772++ }
2773++
2774++ public String getNString(int columnIndex) throws SQLException
2775++ {
2776++ ResultSet resultSet = getUnderlyingResultSet();
2777++ try
2778++ {
2779++ return resultSet.getNString(columnIndex);
2780++ }
2781++ catch (Throwable t)
2782++ {
2783++ throw checkException(t);
2784++ }
2785++ }
2786++
2787++ public String getNString(String columnLabel) throws SQLException
2788++ {
2789++ ResultSet resultSet = getUnderlyingResultSet();
2790++ try
2791++ {
2792++ return resultSet.getNString(columnLabel);
2793++ }
2794++ catch (Throwable t)
2795++ {
2796++ throw checkException(t);
2797++ }
2798++ }
2799++
2800++ public RowId getRowId(int columnIndex) throws SQLException
2801++ {
2802++ ResultSet resultSet = getUnderlyingResultSet();
2803++ try
2804++ {
2805++ return resultSet.getRowId(columnIndex);
2806++ }
2807++ catch (Throwable t)
2808++ {
2809++ throw checkException(t);
2810++ }
2811++ }
2812++
2813++ public RowId getRowId(String columnLabel) throws SQLException
2814++ {
2815++ ResultSet resultSet = getUnderlyingResultSet();
2816++ try
2817++ {
2818++ return resultSet.getRowId(columnLabel);
2819++ }
2820++ catch (Throwable t)
2821++ {
2822++ throw checkException(t);
2823++ }
2824++ }
2825++
2826++ public SQLXML getSQLXML(int columnIndex) throws SQLException
2827++ {
2828++ ResultSet resultSet = getUnderlyingResultSet();
2829++ try
2830++ {
2831++ return resultSet.getSQLXML(columnIndex);
2832++ }
2833++ catch (Throwable t)
2834++ {
2835++ throw checkException(t);
2836++ }
2837++ }
2838++
2839++ public SQLXML getSQLXML(String columnLabel) throws SQLException
2840++ {
2841++ ResultSet resultSet = getUnderlyingResultSet();
2842++ try
2843++ {
2844++ return resultSet.getSQLXML(columnLabel);
2845++ }
2846++ catch (Throwable t)
2847++ {
2848++ throw checkException(t);
2849++ }
2850++ }
2851++
2852++ public boolean isClosed() throws SQLException
2853++ {
2854++ ResultSet resultSet = getWrappedObject();
2855++ if (resultSet == null)
2856++ return true;
2857++ try
2858++ {
2859++ return resultSet.isClosed();
2860++ }
2861++ catch (Throwable t)
2862++ {
2863++ throw checkException(t);
2864++ }
2865++ }
2866++
2867++ public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException
2868++ {
2869++ ResultSet resultSet = getUnderlyingResultSet();
2870++ try
2871++ {
2872++ resultSet.updateAsciiStream(columnIndex, x, length);
2873++ }
2874++ catch (Throwable t)
2875++ {
2876++ throw checkException(t);
2877++ }
2878++ }
2879++
2880++ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException
2881++ {
2882++ ResultSet resultSet = getUnderlyingResultSet();
2883++ try
2884++ {
2885++ resultSet.updateAsciiStream(columnIndex, x);
2886++ }
2887++ catch (Throwable t)
2888++ {
2889++ throw checkException(t);
2890++ }
2891++ }
2892++
2893++ public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException
2894++ {
2895++ ResultSet resultSet = getUnderlyingResultSet();
2896++ try
2897++ {
2898++ resultSet.updateAsciiStream(columnLabel, x, length);
2899++ }
2900++ catch (Throwable t)
2901++ {
2902++ throw checkException(t);
2903++ }
2904++ }
2905++
2906++ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException
2907++ {
2908++ ResultSet resultSet = getUnderlyingResultSet();
2909++ try
2910++ {
2911++ resultSet.updateAsciiStream(columnLabel, x);
2912++ }
2913++ catch (Throwable t)
2914++ {
2915++ throw checkException(t);
2916++ }
2917++ }
2918++
2919++ public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException
2920++ {
2921++ ResultSet resultSet = getUnderlyingResultSet();
2922++ try
2923++ {
2924++ resultSet.updateBinaryStream(columnIndex, x, length);
2925++ }
2926++ catch (Throwable t)
2927++ {
2928++ throw checkException(t);
2929++ }
2930++ }
2931++
2932++ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException
2933++ {
2934++ ResultSet resultSet = getUnderlyingResultSet();
2935++ try
2936++ {
2937++ resultSet.updateBinaryStream(columnIndex, x);
2938++ }
2939++ catch (Throwable t)
2940++ {
2941++ throw checkException(t);
2942++ }
2943++ }
2944++
2945++ public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException
2946++ {
2947++ ResultSet resultSet = getUnderlyingResultSet();
2948++ try
2949++ {
2950++ resultSet.updateBinaryStream(columnLabel, x, length);
2951++ }
2952++ catch (Throwable t)
2953++ {
2954++ throw checkException(t);
2955++ }
2956++ }
2957++
2958++ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException
2959++ {
2960++ ResultSet resultSet = getUnderlyingResultSet();
2961++ try
2962++ {
2963++ resultSet.updateBinaryStream(columnLabel, x);
2964++ }
2965++ catch (Throwable t)
2966++ {
2967++ throw checkException(t);
2968++ }
2969++ }
2970++
2971++ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException
2972++ {
2973++ ResultSet resultSet = getUnderlyingResultSet();
2974++ try
2975++ {
2976++ resultSet.updateBlob(columnIndex, inputStream, length);
2977++ }
2978++ catch (Throwable t)
2979++ {
2980++ throw checkException(t);
2981++ }
2982++ }
2983++
2984++ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException
2985++ {
2986++ ResultSet resultSet = getUnderlyingResultSet();
2987++ try
2988++ {
2989++ resultSet.updateBlob(columnIndex, inputStream);
2990++ }
2991++ catch (Throwable t)
2992++ {
2993++ throw checkException(t);
2994++ }
2995++ }
2996++
2997++ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException
2998++ {
2999++ ResultSet resultSet = getUnderlyingResultSet();
3000++ try
3001++ {
3002++ resultSet.updateBlob(columnLabel, inputStream, length);
3003++ }
3004++ catch (Throwable t)
3005++ {
3006++ throw checkException(t);
3007++ }
3008++ }
3009++
3010++ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException
3011++ {
3012++ ResultSet resultSet = getUnderlyingResultSet();
3013++ try
3014++ {
3015++ resultSet.updateBlob(columnLabel, inputStream);
3016++ }
3017++ catch (Throwable t)
3018++ {
3019++ throw checkException(t);
3020++ }
3021++ }
3022++
3023++ public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException
3024++ {
3025++ ResultSet resultSet = getUnderlyingResultSet();
3026++ try
3027++ {
3028++ resultSet.updateCharacterStream(columnIndex, x, length);
3029++ }
3030++ catch (Throwable t)
3031++ {
3032++ throw checkException(t);
3033++ }
3034++ }
3035++
3036++ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException
3037++ {
3038++ ResultSet resultSet = getUnderlyingResultSet();
3039++ try
3040++ {
3041++ resultSet.updateCharacterStream(columnIndex, x);
3042++ }
3043++ catch (Throwable t)
3044++ {
3045++ throw checkException(t);
3046++ }
3047++ }
3048++
3049++ public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException
3050++ {
3051++ ResultSet resultSet = getUnderlyingResultSet();
3052++ try
3053++ {
3054++ resultSet.updateCharacterStream(columnLabel, reader, length);
3055++ }
3056++ catch (Throwable t)
3057++ {
3058++ throw checkException(t);
3059++ }
3060++ }
3061++
3062++ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException
3063++ {
3064++ ResultSet resultSet = getUnderlyingResultSet();
3065++ try
3066++ {
3067++ resultSet.updateCharacterStream(columnLabel, reader);
3068++ }
3069++ catch (Throwable t)
3070++ {
3071++ throw checkException(t);
3072++ }
3073++ }
3074++
3075++ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException
3076++ {
3077++ ResultSet resultSet = getUnderlyingResultSet();
3078++ try
3079++ {
3080++ resultSet.updateClob(columnIndex, reader, length);
3081++ }
3082++ catch (Throwable t)
3083++ {
3084++ throw checkException(t);
3085++ }
3086++ }
3087++
3088++ public void updateClob(int columnIndex, Reader reader) throws SQLException
3089++ {
3090++ ResultSet resultSet = getUnderlyingResultSet();
3091++ try
3092++ {
3093++ resultSet.updateClob(columnIndex, reader);
3094++ }
3095++ catch (Throwable t)
3096++ {
3097++ throw checkException(t);
3098++ }
3099++ }
3100++
3101++ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException
3102++ {
3103++ ResultSet resultSet = getUnderlyingResultSet();
3104++ try
3105++ {
3106++ resultSet.updateClob(columnLabel, reader, length);
3107++ }
3108++ catch (Throwable t)
3109++ {
3110++ throw checkException(t);
3111++ }
3112++ }
3113++
3114++ public void updateClob(String columnLabel, Reader reader) throws SQLException
3115++ {
3116++ ResultSet resultSet = getUnderlyingResultSet();
3117++ try
3118++ {
3119++ resultSet.updateClob(columnLabel, reader);
3120++ }
3121++ catch (Throwable t)
3122++ {
3123++ throw checkException(t);
3124++ }
3125++ }
3126++
3127++ public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException
3128++ {
3129++ ResultSet resultSet = getUnderlyingResultSet();
3130++ try
3131++ {
3132++ resultSet.updateNCharacterStream(columnIndex, x, length);
3133++ }
3134++ catch (Throwable t)
3135++ {
3136++ throw checkException(t);
3137++ }
3138++ }
3139++
3140++ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException
3141++ {
3142++ ResultSet resultSet = getUnderlyingResultSet();
3143++ try
3144++ {
3145++ resultSet.updateNCharacterStream(columnIndex, x);
3146++ }
3147++ catch (Throwable t)
3148++ {
3149++ throw checkException(t);
3150++ }
3151++ }
3152++
3153++ public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException
3154++ {
3155++ ResultSet resultSet = getUnderlyingResultSet();
3156++ try
3157++ {
3158++ resultSet.updateNCharacterStream(columnLabel, reader, length);
3159++ }
3160++ catch (Throwable t)
3161++ {
3162++ throw checkException(t);
3163++ }
3164++ }
3165++
3166++ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException
3167++ {
3168++ ResultSet resultSet = getUnderlyingResultSet();
3169++ try
3170++ {
3171++ resultSet.updateNCharacterStream(columnLabel, reader);
3172++ }
3173++ catch (Throwable t)
3174++ {
3175++ throw checkException(t);
3176++ }
3177++ }
3178++
3179++ public void updateNClob(int columnIndex, NClob clob) throws SQLException
3180++ {
3181++ ResultSet resultSet = getUnderlyingResultSet();
3182++ try
3183++ {
3184++ resultSet.updateNClob(columnIndex, clob);
3185++ }
3186++ catch (Throwable t)
3187++ {
3188++ throw checkException(t);
3189++ }
3190++ }
3191++
3192++ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException
3193++ {
3194++ ResultSet resultSet = getUnderlyingResultSet();
3195++ try
3196++ {
3197++ resultSet.updateNClob(columnIndex, reader, length);
3198++ }
3199++ catch (Throwable t)
3200++ {
3201++ throw checkException(t);
3202++ }
3203++ }
3204++
3205++ public void updateNClob(int columnIndex, Reader reader) throws SQLException
3206++ {
3207++ ResultSet resultSet = getUnderlyingResultSet();
3208++ try
3209++ {
3210++ resultSet.updateNClob(columnIndex, reader);
3211++ }
3212++ catch (Throwable t)
3213++ {
3214++ throw checkException(t);
3215++ }
3216++ }
3217++
3218++ public void updateNClob(String columnLabel, NClob clob) throws SQLException
3219++ {
3220++ ResultSet resultSet = getUnderlyingResultSet();
3221++ try
3222++ {
3223++ resultSet.updateNClob(columnLabel, clob);
3224++ }
3225++ catch (Throwable t)
3226++ {
3227++ throw checkException(t);
3228++ }
3229++ }
3230++
3231++ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException
3232++ {
3233++ ResultSet resultSet = getUnderlyingResultSet();
3234++ try
3235++ {
3236++ resultSet.updateNClob(columnLabel, reader, length);
3237++ }
3238++ catch (Throwable t)
3239++ {
3240++ throw checkException(t);
3241++ }
3242++ }
3243++
3244++ public void updateNClob(String columnLabel, Reader reader) throws SQLException
3245++ {
3246++ ResultSet resultSet = getUnderlyingResultSet();
3247++ try
3248++ {
3249++ resultSet.updateNClob(columnLabel, reader);
3250++ }
3251++ catch (Throwable t)
3252++ {
3253++ throw checkException(t);
3254++ }
3255++ }
3256++
3257++ public void updateNString(int columnIndex, String string) throws SQLException
3258++ {
3259++ ResultSet resultSet = getUnderlyingResultSet();
3260++ try
3261++ {
3262++ resultSet.updateNString(columnIndex, string);
3263++ }
3264++ catch (Throwable t)
3265++ {
3266++ throw checkException(t);
3267++ }
3268++ }
3269++
3270++ public void updateNString(String columnLabel, String string) throws SQLException
3271++ {
3272++ ResultSet resultSet = getUnderlyingResultSet();
3273++ try
3274++ {
3275++ resultSet.updateNString(columnLabel, string);
3276++ }
3277++ catch (Throwable t)
3278++ {
3279++ throw checkException(t);
3280++ }
3281++ }
3282++
3283++ public void updateRowId(int columnIndex, RowId x) throws SQLException
3284++ {
3285++ ResultSet resultSet = getUnderlyingResultSet();
3286++ try
3287++ {
3288++ resultSet.updateRowId(columnIndex, x);
3289++ }
3290++ catch (Throwable t)
3291++ {
3292++ throw checkException(t);
3293++ }
3294++ }
3295++
3296++ public void updateRowId(String columnLabel, RowId x) throws SQLException
3297++ {
3298++ ResultSet resultSet = getUnderlyingResultSet();
3299++ try
3300++ {
3301++ resultSet.updateRowId(columnLabel, x);
3302++ }
3303++ catch (Throwable t)
3304++ {
3305++ throw checkException(t);
3306++ }
3307++ }
3308++
3309++ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException
3310++ {
3311++ ResultSet resultSet = getUnderlyingResultSet();
3312++ try
3313++ {
3314++ resultSet.updateSQLXML(columnIndex, xmlObject);
3315++ }
3316++ catch (Throwable t)
3317++ {
3318++ throw checkException(t);
3319++ }
3320++ }
3321++
3322++ public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException
3323++ {
3324++ ResultSet resultSet = getUnderlyingResultSet();
3325++ try
3326++ {
3327++ resultSet.updateSQLXML(columnLabel, xmlObject);
3328++ }
3329++ catch (Throwable t)
3330++ {
3331++ throw checkException(t);
3332++ }
3333++ }
3334++
3335++ public <T> T getObject(String parameterName, Class<T> type) throws SQLException
3336++ {
3337++ ResultSet resultSet = getUnderlyingResultSet();
3338++ try
3339++ {
3340++ return resultSet.getObject(parameterName, type);
3341++ }
3342++ catch (Throwable t)
3343++ {
3344++ throw checkException(t);
3345++ }
3346++ }
3347++
3348++ public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException
3349++ {
3350++ ResultSet resultSet = getUnderlyingResultSet();
3351++ try
3352++ {
3353++ return resultSet.getObject(parameterIndex, type);
3354++ }
3355++ catch (Throwable t)
3356++ {
3357++ throw checkException(t);
3358++ }
3359++ }
3360++}
3361+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedStatementJDK7.java
3362+===================================================================
3363+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
3364++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/jdk7/WrappedStatementJDK7.java 2012-07-30 20:17:25.962593677 -0300
3365+@@ -0,0 +1,152 @@
3366++/*
3367++ * JBoss, Home of Professional Open Source.
3368++ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
3369++ * as indicated by the @author tags. See the copyright.txt file in the
3370++ * distribution for a full listing of individual contributors.
3371++ *
3372++ * This is free software; you can redistribute it and/or modify it
3373++ * under the terms of the GNU Lesser General Public License as
3374++ * published by the Free Software Foundation; either version 2.1 of
3375++ * the License, or (at your option) any later version.
3376++ *
3377++ * This software is distributed in the hope that it will be useful,
3378++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
3379++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3380++ * Lesser General Public License for more details.
3381++ *
3382++ * You should have received a copy of the GNU Lesser General Public
3383++ * License along with this software; if not, write to the Free
3384++ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
3385++ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
3386++ */
3387++package org.jboss.resource.adapter.jdbc.jdk7;
3388++
3389++import java.sql.ResultSet;
3390++import java.sql.SQLException;
3391++import java.sql.Statement;
3392++
3393++import org.jboss.resource.adapter.jdbc.WrappedResultSet;
3394++import org.jboss.resource.adapter.jdbc.WrappedStatement;
3395++
3396++/**
3397++ * WrappedStatementJDK7.
3398++ *
3399++ * @author <a href="adrian@jboss.com">Adrian Brock</a>
3400++ * @version $Revision: 1.1 $
3401++ */
3402++public class WrappedStatementJDK7 extends WrappedStatement
3403++{
3404++ public WrappedStatementJDK7(WrappedConnectionJDK7 lc, Statement s)
3405++ {
3406++ super(lc, s);
3407++ }
3408++
3409++ protected WrappedResultSet wrapResultSet(ResultSet resultSet)
3410++ {
3411++ return new WrappedResultSetJDK7(this, resultSet);
3412++ }
3413++
3414++ public boolean isClosed() throws SQLException
3415++ {
3416++ lock();
3417++ try
3418++ {
3419++ Statement wrapped = getWrappedObject();
3420++ if (wrapped == null)
3421++ return true;
3422++ return wrapped.isClosed();
3423++ }
3424++ catch (Throwable t)
3425++ {
3426++ throw checkException(t);
3427++ }
3428++ finally
3429++ {
3430++ unlock();
3431++ }
3432++ }
3433++
3434++ public boolean isPoolable() throws SQLException
3435++ {
3436++ lock();
3437++ try
3438++ {
3439++ Statement statement = getUnderlyingStatement();
3440++ try
3441++ {
3442++ return statement.isPoolable();
3443++ }
3444++ catch (Throwable t)
3445++ {
3446++ throw checkException(t);
3447++ }
3448++ }
3449++ finally
3450++ {
3451++ unlock();
3452++ }
3453++ }
3454++
3455++ public void setPoolable(boolean poolable) throws SQLException
3456++ {
3457++ lock();
3458++ try
3459++ {
3460++ Statement statement = getUnderlyingStatement();
3461++ try
3462++ {
3463++ statement.setPoolable(poolable);
3464++ }
3465++ catch (Throwable t)
3466++ {
3467++ throw checkException(t);
3468++ }
3469++ }
3470++ finally
3471++ {
3472++ unlock();
3473++ }
3474++ }
3475++
3476++ public boolean isCloseOnCompletion() throws SQLException
3477++ {
3478++ lock();
3479++ try
3480++ {
3481++ Statement statement = getUnderlyingStatement();
3482++ try
3483++ {
3484++ return statement.isCloseOnCompletion();
3485++ }
3486++ catch (Throwable t)
3487++ {
3488++ throw checkException(t);
3489++ }
3490++ }
3491++ finally
3492++ {
3493++ unlock();
3494++ }
3495++ }
3496++
3497++ public void closeOnCompletion() throws SQLException
3498++ {
3499++ lock();
3500++ try
3501++ {
3502++ Statement statement = getUnderlyingStatement();
3503++ try
3504++ {
3505++ statement.closeOnCompletion();
3506++ }
3507++ catch (Throwable t)
3508++ {
3509++ throw checkException(t);
3510++ }
3511++ }
3512++ finally
3513++ {
3514++ unlock();
3515++ }
3516++ }
3517++}
3518+Index: fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/BaseWrapperManagedConnection.java
3519+===================================================================
3520+--- fix-for-888943.orig/connector/src/main/org/jboss/resource/adapter/jdbc/BaseWrapperManagedConnection.java 2012-07-25 15:48:09.561627627 -0300
3521++++ fix-for-888943/connector/src/main/org/jboss/resource/adapter/jdbc/BaseWrapperManagedConnection.java 2012-07-30 19:58:28.316952413 -0300
3522+@@ -65,7 +65,7 @@
3523+ public abstract class BaseWrapperManagedConnection implements ManagedConnection , JBossConnectionStatistics
3524+ {
3525+ private static final WrappedConnectionFactory wrappedConnectionFactory;
3526+-
3527++
3528+ protected final BaseWrapperManagedConnectionFactory mcf;
3529+
3530+ protected final Connection con;
3531+@@ -101,23 +101,31 @@
3532+ protected int jdbcTransactionIsolation;
3533+
3534+ protected boolean destroyed = false;
3535+-
3536++
3537+ static
3538+ {
3539+ Class connectionFactory = null;
3540++
3541+ try
3542+ {
3543+- connectionFactory = BaseWrapperManagedConnection.class.forName("org.jboss.resource.adapter.jdbc.jdk6.WrappedConnectionFactoryJDK6");
3544++ connectionFactory = BaseWrapperManagedConnection.class.forName("org.jboss.resource.adapter.jdbc.jdk7.WrappedConnectionFactoryJDK7");
3545+ }
3546+- catch (ClassNotFoundException e)
3547++ catch (ClassNotFoundException e7)
3548+ {
3549+ try
3550+ {
3551+- connectionFactory = BaseWrapperManagedConnection.class.forName("org.jboss.resource.adapter.jdbc.jdk5.WrappedConnectionFactoryJDK5");
3552++ connectionFactory = BaseWrapperManagedConnection.class.forName("org.jboss.resource.adapter.jdbc.jdk6.WrappedConnectionFactoryJDK6");
3553+ }
3554+- catch (ClassNotFoundException ex)
3555++ catch (ClassNotFoundException e6)
3556+ {
3557+- throw new RuntimeException("Unabled to load wrapped connection factory", ex);
3558++ try
3559++ {
3560++ connectionFactory = BaseWrapperManagedConnection.class.forName("org.jboss.resource.adapter.jdbc.jdk5.WrappedConnectionFactoryJDK5");
3561++ }
3562++ catch (ClassNotFoundException e5)
3563++ {
3564++ throw new RuntimeException("Unabled to load wrapped connection factory", e5);
3565++ }
3566+ }
3567+ }
3568+ try
3569+@@ -272,7 +280,7 @@
3570+ throw new SQLException("Interrupted attempting lock: " + this);
3571+ }
3572+ }
3573+-
3574++
3575+ protected void unlock()
3576+ {
3577+ lock.unlock();
3578+@@ -735,7 +743,7 @@
3579+ connectionError(e);
3580+ throw new JBossResourceException("SQLException", e);
3581+ }
3582+-
3583++
3584+ public Object listConnectionStats()
3585+ {
3586+ if(psCache != null)
3587
3588=== modified file 'debian/patches/series'
3589--- debian/patches/series 2011-06-03 16:08:07 +0000
3590+++ debian/patches/series 2012-09-21 04:33:21 +0000
3591@@ -9,3 +9,5 @@
3592 deployers.diff
3593 hibernate35.diff
3594 hibernate36.diff
3595+jdk7-jdbc.diff
3596+ejb3-jdk7.diff

Subscribers

People subscribed via source and target branches