001: /*
002: * Copyright 2001-2007 Geert Bevin <gbevin[remove] at uwyn dot com>
003: * Distributed under the terms of either:
004: * - the common development and distribution license (CDDL), v1.0; or
005: * - the GNU Lesser General Public License, v2.1 or later
006: * $Id: DbResultSet40.java 3690 2007-03-12 13:42:09Z gbevin $
007: */
008: package com.uwyn.rife.database;
009:
010: import com.uwyn.rife.database.exceptions.RowIndexOutOfBoundsException;
011: import java.io.InputStream;
012: import java.io.Reader;
013: import java.sql.NClob;
014: import java.sql.ResultSet;
015: import java.sql.RowId;
016: import java.sql.SQLException;
017: import java.sql.SQLXML;
018:
019: public class DbResultSet40 extends DbResultSet {
020: DbResultSet40(DbStatement statement, ResultSet resultSet) {
021: super (statement, resultSet);
022: }
023:
024: public RowId getRowId(int columnIndex) throws SQLException {
025: if (mFirstRowSkew) {
026: throw new RowIndexOutOfBoundsException();
027: }
028:
029: return mResultSet.getRowId(columnIndex);
030: }
031:
032: public RowId getRowId(String columnLabel) throws SQLException {
033: if (mFirstRowSkew) {
034: throw new RowIndexOutOfBoundsException();
035: }
036:
037: return mResultSet.getRowId(columnLabel);
038: }
039:
040: public void updateRowId(int columnIndex, RowId x)
041: throws SQLException {
042: if (mFirstRowSkew) {
043: throw new RowIndexOutOfBoundsException();
044: }
045:
046: mResultSet.updateRowId(columnIndex, x);
047: }
048:
049: public void updateRowId(String columnLabel, RowId x)
050: throws SQLException {
051: if (mFirstRowSkew) {
052: throw new RowIndexOutOfBoundsException();
053: }
054:
055: mResultSet.updateRowId(columnLabel, x);
056: }
057:
058: public int getHoldability() throws SQLException {
059: return mResultSet.getHoldability();
060: }
061:
062: public boolean isClosed() throws SQLException {
063: return mResultSet.isClosed();
064: }
065:
066: public void updateNString(int columnIndex, String nString)
067: throws SQLException {
068: if (mFirstRowSkew) {
069: throw new RowIndexOutOfBoundsException();
070: }
071:
072: mResultSet.updateNString(columnIndex, nString);
073: }
074:
075: public void updateNString(String columnLabel, String nString)
076: throws SQLException {
077: if (mFirstRowSkew) {
078: throw new RowIndexOutOfBoundsException();
079: }
080:
081: mResultSet.updateNString(columnLabel, nString);
082: }
083:
084: public void updateNClob(int columnIndex, NClob nClob)
085: throws SQLException {
086: if (mFirstRowSkew) {
087: throw new RowIndexOutOfBoundsException();
088: }
089:
090: mResultSet.updateNClob(columnIndex, nClob);
091: }
092:
093: public void updateNClob(String columnLabel, NClob nClob)
094: throws SQLException {
095: if (mFirstRowSkew) {
096: throw new RowIndexOutOfBoundsException();
097: }
098:
099: mResultSet.updateNClob(columnLabel, nClob);
100: }
101:
102: public NClob getNClob(int columnIndex) throws SQLException {
103: if (mFirstRowSkew) {
104: throw new RowIndexOutOfBoundsException();
105: }
106:
107: return mResultSet.getNClob(columnIndex);
108: }
109:
110: public NClob getNClob(String columnLabel) throws SQLException {
111: if (mFirstRowSkew) {
112: throw new RowIndexOutOfBoundsException();
113: }
114:
115: return mResultSet.getNClob(columnLabel);
116: }
117:
118: public SQLXML getSQLXML(int columnIndex) throws SQLException {
119: if (mFirstRowSkew) {
120: throw new RowIndexOutOfBoundsException();
121: }
122:
123: return mResultSet.getSQLXML(columnIndex);
124: }
125:
126: public SQLXML getSQLXML(String columnLabel) throws SQLException {
127: if (mFirstRowSkew) {
128: throw new RowIndexOutOfBoundsException();
129: }
130:
131: return mResultSet.getSQLXML(columnLabel);
132: }
133:
134: public void updateSQLXML(int columnIndex, SQLXML xmlObject)
135: throws SQLException {
136: if (mFirstRowSkew) {
137: throw new RowIndexOutOfBoundsException();
138: }
139:
140: mResultSet.updateSQLXML(columnIndex, xmlObject);
141: }
142:
143: public void updateSQLXML(String columnLabel, SQLXML xmlObject)
144: throws SQLException {
145: if (mFirstRowSkew) {
146: throw new RowIndexOutOfBoundsException();
147: }
148:
149: mResultSet.updateSQLXML(columnLabel, xmlObject);
150: }
151:
152: public String getNString(int columnIndex) throws SQLException {
153: if (mFirstRowSkew) {
154: throw new RowIndexOutOfBoundsException();
155: }
156:
157: return mResultSet.getNString(columnIndex);
158: }
159:
160: public String getNString(String columnLabel) throws SQLException {
161: if (mFirstRowSkew) {
162: throw new RowIndexOutOfBoundsException();
163: }
164:
165: return mResultSet.getNString(columnLabel);
166: }
167:
168: public Reader getNCharacterStream(int columnIndex)
169: throws SQLException {
170: if (mFirstRowSkew) {
171: throw new RowIndexOutOfBoundsException();
172: }
173:
174: return mResultSet.getNCharacterStream(columnIndex);
175: }
176:
177: public Reader getNCharacterStream(String columnLabel)
178: throws SQLException {
179: if (mFirstRowSkew) {
180: throw new RowIndexOutOfBoundsException();
181: }
182:
183: return mResultSet.getNCharacterStream(columnLabel);
184: }
185:
186: public void updateNCharacterStream(int columnIndex, Reader x)
187: throws SQLException {
188: if (mFirstRowSkew) {
189: throw new RowIndexOutOfBoundsException();
190: }
191:
192: mResultSet.updateNCharacterStream(columnIndex, x);
193: }
194:
195: public void updateNCharacterStream(int columnIndex, Reader x,
196: long length) throws SQLException {
197: if (mFirstRowSkew) {
198: throw new RowIndexOutOfBoundsException();
199: }
200:
201: mResultSet.updateNCharacterStream(columnIndex, x, length);
202: }
203:
204: public void updateNCharacterStream(String columnLabel, Reader reader)
205: throws SQLException {
206: if (mFirstRowSkew) {
207: throw new RowIndexOutOfBoundsException();
208: }
209:
210: mResultSet.updateNCharacterStream(columnLabel, reader);
211: }
212:
213: public void updateNCharacterStream(String columnLabel,
214: Reader reader, long length) throws SQLException {
215: if (mFirstRowSkew) {
216: throw new RowIndexOutOfBoundsException();
217: }
218:
219: mResultSet.updateNCharacterStream(columnLabel, reader, length);
220: }
221:
222: public void updateAsciiStream(int columnIndex, InputStream x)
223: throws SQLException {
224: if (mFirstRowSkew) {
225: throw new RowIndexOutOfBoundsException();
226: }
227:
228: mResultSet.updateAsciiStream(columnIndex, x);
229: }
230:
231: public void updateAsciiStream(int columnIndex, InputStream x,
232: long length) throws SQLException {
233: if (mFirstRowSkew) {
234: throw new RowIndexOutOfBoundsException();
235: }
236:
237: mResultSet.updateAsciiStream(columnIndex, x, length);
238: }
239:
240: public void updateBinaryStream(int columnIndex, InputStream x)
241: throws SQLException {
242: if (mFirstRowSkew) {
243: throw new RowIndexOutOfBoundsException();
244: }
245:
246: mResultSet.updateBinaryStream(columnIndex, x);
247: }
248:
249: public void updateBinaryStream(int columnIndex, InputStream x,
250: long length) throws SQLException {
251: if (mFirstRowSkew) {
252: throw new RowIndexOutOfBoundsException();
253: }
254:
255: mResultSet.updateBinaryStream(columnIndex, x, length);
256: }
257:
258: public void updateCharacterStream(int columnIndex, Reader x)
259: throws SQLException {
260: if (mFirstRowSkew) {
261: throw new RowIndexOutOfBoundsException();
262: }
263:
264: mResultSet.updateCharacterStream(columnIndex, x);
265: }
266:
267: public void updateCharacterStream(int columnIndex, Reader x,
268: long length) throws SQLException {
269: if (mFirstRowSkew) {
270: throw new RowIndexOutOfBoundsException();
271: }
272:
273: mResultSet.updateCharacterStream(columnIndex, x, length);
274: }
275:
276: public void updateAsciiStream(String columnLabel, InputStream x)
277: throws SQLException {
278: if (mFirstRowSkew) {
279: throw new RowIndexOutOfBoundsException();
280: }
281:
282: mResultSet.updateAsciiStream(columnLabel, x);
283: }
284:
285: public void updateAsciiStream(String columnLabel, InputStream x,
286: long length) throws SQLException {
287: if (mFirstRowSkew) {
288: throw new RowIndexOutOfBoundsException();
289: }
290:
291: mResultSet.updateAsciiStream(columnLabel, x, length);
292: }
293:
294: public void updateBinaryStream(String columnLabel, InputStream x)
295: throws SQLException {
296: if (mFirstRowSkew) {
297: throw new RowIndexOutOfBoundsException();
298: }
299:
300: mResultSet.updateBinaryStream(columnLabel, x);
301: }
302:
303: public void updateBinaryStream(String columnLabel, InputStream x,
304: long length) throws SQLException {
305: if (mFirstRowSkew) {
306: throw new RowIndexOutOfBoundsException();
307: }
308:
309: mResultSet.updateBinaryStream(columnLabel, x, length);
310: }
311:
312: public void updateCharacterStream(String columnLabel, Reader reader)
313: throws SQLException {
314: if (mFirstRowSkew) {
315: throw new RowIndexOutOfBoundsException();
316: }
317:
318: mResultSet.updateCharacterStream(columnLabel, reader);
319: }
320:
321: public void updateCharacterStream(String columnLabel,
322: Reader reader, long length) throws SQLException {
323: if (mFirstRowSkew) {
324: throw new RowIndexOutOfBoundsException();
325: }
326:
327: mResultSet.updateCharacterStream(columnLabel, reader, length);
328: }
329:
330: public void updateBlob(int columnIndex, InputStream inputStream)
331: throws SQLException {
332: if (mFirstRowSkew) {
333: throw new RowIndexOutOfBoundsException();
334: }
335:
336: mResultSet.updateBlob(columnIndex, inputStream);
337: }
338:
339: public void updateBlob(String columnLabel, InputStream inputStream)
340: throws SQLException {
341: if (mFirstRowSkew) {
342: throw new RowIndexOutOfBoundsException();
343: }
344:
345: mResultSet.updateBlob(columnLabel, inputStream);
346: }
347:
348: public void updateBlob(int columnIndex, InputStream inputStream,
349: long length) throws SQLException {
350: if (mFirstRowSkew) {
351: throw new RowIndexOutOfBoundsException();
352: }
353:
354: mResultSet.updateBlob(columnIndex, inputStream, length);
355: }
356:
357: public void updateBlob(String columnLabel, InputStream inputStream,
358: long length) throws SQLException {
359: if (mFirstRowSkew) {
360: throw new RowIndexOutOfBoundsException();
361: }
362:
363: mResultSet.updateBlob(columnLabel, inputStream, length);
364: }
365:
366: public void updateClob(int columnIndex, Reader reader)
367: throws SQLException {
368: if (mFirstRowSkew) {
369: throw new RowIndexOutOfBoundsException();
370: }
371:
372: mResultSet.updateClob(columnIndex, reader);
373: }
374:
375: public void updateClob(String columnLabel, Reader reader)
376: throws SQLException {
377: if (mFirstRowSkew) {
378: throw new RowIndexOutOfBoundsException();
379: }
380:
381: mResultSet.updateClob(columnLabel, reader);
382: }
383:
384: public void updateClob(int columnIndex, Reader reader, long length)
385: throws SQLException {
386: if (mFirstRowSkew) {
387: throw new RowIndexOutOfBoundsException();
388: }
389:
390: mResultSet.updateClob(columnIndex, reader, length);
391: }
392:
393: public void updateClob(String columnLabel, Reader reader,
394: long length) throws SQLException {
395: if (mFirstRowSkew) {
396: throw new RowIndexOutOfBoundsException();
397: }
398:
399: mResultSet.updateClob(columnLabel, reader, length);
400: }
401:
402: public void updateNClob(String columnLabel, Reader reader)
403: throws SQLException {
404: if (mFirstRowSkew) {
405: throw new RowIndexOutOfBoundsException();
406: }
407:
408: mResultSet.updateNClob(columnLabel, reader);
409: }
410:
411: public void updateNClob(int columnIndex, Reader reader)
412: throws SQLException {
413: if (mFirstRowSkew) {
414: throw new RowIndexOutOfBoundsException();
415: }
416:
417: mResultSet.updateNClob(columnIndex, reader);
418: }
419:
420: public void updateNClob(int columnIndex, Reader reader, long length)
421: throws SQLException {
422: if (mFirstRowSkew) {
423: throw new RowIndexOutOfBoundsException();
424: }
425:
426: mResultSet.updateNClob(columnIndex, reader, length);
427: }
428:
429: public void updateNClob(String columnLabel, Reader reader,
430: long length) throws SQLException {
431: if (mFirstRowSkew) {
432: throw new RowIndexOutOfBoundsException();
433: }
434:
435: mResultSet.updateNClob(columnLabel, reader, length);
436: }
437:
438: public <T extends Object> T unwrap(Class<T> iface)
439: throws SQLException {
440: return mResultSet.unwrap(iface);
441: }
442:
443: public boolean isWrapperFor(Class<?> iface) throws SQLException {
444: return mResultSet.isWrapperFor(iface);
445: }
446: }
|