1 /***
2 Copyright (C) 2002-2003 Together
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with this library; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18 */
19
20 package org.webdocwf.util.i18njdbc;
21
22 import java.io.ByteArrayInputStream;
23 import java.io.IOException;
24 import java.io.InputStream;
25 import java.io.Reader;
26 import java.io.StringReader;
27 import java.math.BigDecimal;
28 import java.net.URL;
29 import java.sql.*;
30 import java.util.Calendar;
31 import java.util.Enumeration;
32 import java.util.Map;
33
34 /***
35 * This class implements the ResultSet interface for the I18nJdbc driver.
36 *
37 * @author Zoran Milakovic
38 * @author Zeljko Kovacevic
39 */
40 public class I18nResultSet implements ResultSet {
41
42 /*** Metadata for this ResultSet */
43 protected ResultSetMetaData resultSetMetaData;
44
45 /***Properties */
46 protected I18nProperties properties;
47
48 /*** Table referenced by the Statement */
49 protected String tableName;
50
51 /*** Array of available columns for referenced table */
52 protected String[] columnNames;
53
54 protected String[] columnTypes;
55
56 protected String[] whereColumnNames;
57
58 protected String[] whereColumnValues;
59
60 /*** Last column name index read */
61 protected int lastIndexRead = -1;
62
63 /*** InputStream to keep track of */
64 protected InputStream is;
65
66 protected Enumeration en;
67
68 private String currKey = "";
69
70 protected I18nConnection connection;
71
72
73 /***
74 * Constructor for the I18nResultSet object
75 *
76 * @param statement I18nStatement that produced this ResultSet
77 * @param tableName Table referenced by the Statement
78 * @param columnNames Array of available columns for referenced table
79 * @param columnWhereNames Array of column names in where clause
80 * @param columnWhereValues Array of values in where clause
81 */
82 protected I18nResultSet(I18nStatement statement,
83 String tableName,
84 String[] columnNames,
85 String[] columnWhereNames,
86 String[] columnWhereValues) throws SQLException {
87
88 try {
89 this.connection = (I18nConnection) statement.getConnection();
90 } catch (SQLException e) {
91 throw e;
92 }
93 this.tableName = tableName;
94 this.columnNames = columnNames;
95 this.whereColumnNames = columnWhereNames;
96 this.whereColumnValues = columnWhereValues;
97 this.properties = statement.getProperties();
98 this.en = statement.getProperties().keys();
99
100 if (columnNames[0].equals("*")) {
101 this.columnNames = this.connection.getColumnNames();
102 }
103 }
104 /***
105 * Constructor for the I18nResultSet object
106 *
107 * @param statement I18nPreparedStatement that produced this ResultSet
108 * @param tableName Table referenced by the Statement
109 * @param columnNames Array of available columns for referenced table
110 * @param columnWhereNames Array of column names in where clause
111 * @param columnWhereValues Array of values in where clause
112 */
113 protected I18nResultSet(I18nPreparedStatement statement,
114 String tableName,
115 String[] columnNames,
116 String[] columnWhereNames,
117 String[] columnWhereValues) throws SQLException {
118 try {
119 this.connection = (I18nConnection) statement.getConnection();
120 } catch (SQLException e) {
121 throw e;
122 }
123 this.tableName = tableName;
124 this.columnNames = columnNames;
125 this.whereColumnNames = columnWhereNames;
126 this.whereColumnValues = columnWhereValues;
127 this.properties = statement.getProperties();
128 this.en = statement.getProperties().keys();
129
130 if (columnNames[0].equals("*")) {
131 this.columnNames = this.connection.getColumnNames();
132 }
133 }
134 /***
135 * Moves the cursor down one row from its current position.
136 * A <code>ResultSet</code> cursor is initially positioned
137 * before the first row; the first call to the method
138 * <code>next</code> makes the first row the current row; the
139 * second call makes the second row the current row, and so on.
140 *
141 * <P>If an input stream is open for the current row, a call
142 * to the method <code>next</code> will
143 * implicitly close it. A <code>ResultSet</code> object's
144 * warning chain is cleared when a new row is read.
145 *
146 * @return <code>true</code> if the new current row is valid;
147 * <code>false</code> if there are no more rows
148 * @exception SQLException if a database access error occurs
149 */
150 public boolean next() throws SQLException {
151
152 boolean retVal = false;
153 mainLoop : while (en.hasMoreElements()) {
154 this.currKey = en.nextElement().toString();
155 retVal = true;
156 out : for (int i = 0; i < this.whereColumnNames.length; i++) {
157 if (whereColumnValues[i] == null || whereColumnValues[i].equals("null"))
158 whereColumnValues[i] = "";
159 if (this.whereColumnNames[i].equalsIgnoreCase(this.connection.getNameColumn())) {
160 if (!this.currKey.equals(this.whereColumnValues[i])) {
161 retVal = false;
162 break out;
163 }
164 } else if (this.whereColumnNames[i].equalsIgnoreCase(this.connection.getValueColumn())) {
165 if (!(properties.getProperty(this.currKey).equals(this.whereColumnValues[i]))) {
166 retVal = false;
167 break out;
168 }
169 }
170 }
171 if (retVal == true)
172 return true;
173 }
174 return false;
175 }
176
177 /***
178 * Releases this <code>ResultSet</code> object's database and
179 * JDBC resources immediately instead of waiting for
180 * this to happen when it is automatically closed.
181 *
182 *
183 * <P><B>Note:</B> A <code>ResultSet</code> object
184 * is automatically closed by the
185 * <code>Statement</code> object that generated it when
186 * that <code>Statement</code> object is closed,
187 * re-executed, or is used to retrieve the next result from a
188 * sequence of multiple results. A <code>ResultSet</code> object
189 * is also automatically closed when it is garbage collected.
190 *
191 * @exception SQLException if a database access error occurs
192 */
193 public void close() throws SQLException {
194 // reader.close();
195 }
196
197 /***
198 * Reports whether
199 * the last column read had a value of SQL <code>NULL</code>.
200 * Note that you must first call one of the getter methods
201 * on a column to try to read its value and then call
202 * the method <code>wasNull</code> to see if the value read was
203 * SQL <code>NULL</code>.
204 *
205 * @return <code>true</code> if the last column value read was SQL
206 * <code>NULL</code> and <code>false</code> otherwise
207 * @exception SQLException if a database access error occurs
208 */
209 public boolean wasNull() throws SQLException {
210 if (lastIndexRead >= 0) {
211 return getString(lastIndexRead) == null;
212 } else {
213 throw new SQLException("No previous getter method called");
214 }
215 }
216
217 //======================================================================
218 // Methods for accessing results by column index
219 //======================================================================
220
221 /***
222 * Retrieves the value of the designated column in the current row
223 * of this <code>ResultSet</code> object as
224 * a <code>String</code> in the Java programming language.
225 *
226 * @param columnIndex the first column is 1, the second is 2, ...
227 * @return the column value; if the value is SQL <code>NULL</code>, the
228 * value returned is <code>null</code>
229 * @exception SQLException if a database access error occurs
230 */
231 public String getString(int columnIndex) throws SQLException {
232 // perform pre-accessor method processing
233 String retValue = "";
234 preAccessor(columnIndex);
235 if (columnIndex < 1 || columnIndex > columnNames.length) {
236 throw new SQLException("Column not found: invalid index: " + columnIndex);
237 } else if (columnIndex >= 1) {
238 // I18nConnection conn = (I18nConnection)this.statement.getConnection();
239 String colName = this.connection.getNameColumn();
240 String colValue = this.connection.getValueColumn();
241 String column = columnNames[columnIndex - 1];
242 if (column.equalsIgnoreCase(colName)) {
243 retValue = this.currKey;
244 } else if (column.equalsIgnoreCase(colValue)) {
245 retValue = properties.getProperty(this.currKey);
246 }
247
248 }
249 return retValue;
250
251 }
252
253 /***
254 * Retrieves the value of the designated column in the current row
255 * of this <code>ResultSet</code> object as
256 * a <code>boolean</code> in the Java programming language.
257 *
258 * @param columnIndex the first column is 1, the second is 2, ...
259 * @return the column value; if the value is SQL <code>NULL</code>, the
260 * value returned is <code>false</code>
261 * @exception SQLException if a database access error occurs
262 */
263 public boolean getBoolean(int columnIndex) throws SQLException {
264 String str = getString(columnIndex);
265 return (str == null) ? false : Boolean.valueOf(str).booleanValue();
266 }
267
268 /***
269 * Retrieves the value of the designated column in the current row
270 * of this <code>ResultSet</code> object as
271 * a <code>byte</code> in the Java programming language.
272 *
273 * @param columnIndex the first column is 1, the second is 2, ...
274 * @return the column value; if the value is SQL <code>NULL</code>, the
275 * value returned is <code>0</code>
276 * @exception SQLException if a database access error occurs
277 */
278 public byte getByte(int columnIndex) throws SQLException {
279 String str = getString(columnIndex);
280 return (str == null) ? 0 : Byte.parseByte(str);
281 }
282
283 /***
284 * Retrieves the value of the designated column in the current row
285 * of this <code>ResultSet</code> object as
286 * a <code>short</code> in the Java programming language.
287 *
288 * @param columnIndex the first column is 1, the second is 2, ...
289 * @return the column value; if the value is SQL <code>NULL</code>, the
290 * value returned is <code>0</code>
291 * @exception SQLException if a database access error occurs
292 */
293 public short getShort(int columnIndex) throws SQLException {
294 String str = getString(columnIndex);
295 return (str == null) ? 0 : Short.parseShort(str);
296 }
297
298 /***
299 * Gets the value of the designated column in the current row
300 * of this <code>ResultSet</code> object as
301 * an <code>int</code> in the Java programming language.
302 *
303 * @param columnIndex the first column is 1, the second is 2, ...
304 * @return the column value; if the value is SQL <code>NULL</code>, the
305 * value returned is <code>0</code>
306 * @exception SQLException if a database access error occurs
307 */
308 public int getInt(int columnIndex) throws SQLException {
309 String str = getString(columnIndex);
310 return (str == null) ? 0 : Integer.parseInt(str);
311 }
312
313 /***
314 * Retrieves the value of the designated column in the current row
315 * of this <code>ResultSet</code> object as
316 * a <code>long</code> in the Java programming language.
317 *
318 * @param columnIndex the first column is 1, the second is 2, ...
319 * @return the column value; if the value is SQL <code>NULL</code>, the
320 * value returned is <code>0</code>
321 * @exception SQLException if a database access error occurs
322 */
323 public long getLong(int columnIndex) throws SQLException {
324 String str = getString(columnIndex);
325 return (str == null) ? 0L : Long.parseLong(str);
326 }
327
328 /***
329 * Gets the value of the designated column in the current row
330 * of this <code>ResultSet</code> object as
331 * a <code>float</code> in the Java programming language.
332 *
333 * @param columnIndex the first column is 1, the second is 2, ...
334 * @return the column value; if the value is SQL <code>NULL</code>, the
335 * value returned is <code>0</code>
336 * @exception SQLException if a database access error occurs
337 */
338 public float getFloat(int columnIndex) throws SQLException {
339 String str = getString(columnIndex);
340 return (str == null) ? 0F : Float.parseFloat(str);
341 }
342
343 /***
344 * Retrieves the value of the designated column in the current row
345 * of this <code>ResultSet</code> object as
346 * a <code>double</code> in the Java programming language.
347 *
348 * @param columnIndex the first column is 1, the second is 2, ...
349 * @return the column value; if the value is SQL <code>NULL</code>, the
350 * value returned is <code>0</code>
351 * @exception SQLException if a database access error occurs
352 */
353 public double getDouble(int columnIndex) throws SQLException {
354 String str = getString(columnIndex);
355 return (str == null) ? 0D : Double.parseDouble(str);
356 }
357
358 /***
359 * Retrieves the value of the designated column in the current row
360 * of this <code>ResultSet</code> object as
361 * a <code>java.sql.BigDecimal</code> in the Java programming language.
362 *
363 * @param columnIndex the first column is 1, the second is 2, ...
364 * @param scale the number of digits to the right of the decimal point
365 * @return the column value; if the value is SQL <code>NULL</code>, the
366 * value returned is <code>null</code>
367 * @exception SQLException if a database access error occurs
368 * @deprecated
369 */
370 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
371 // let getBigDecimal(int) handle this for now
372 return getBigDecimal(columnIndex);
373 }
374
375 /***
376 * Retrieves the value of the designated column in the current row
377 * of this <code>ResultSet</code> object as
378 * a <code>byte</code> array in the Java programming language.
379 * The bytes represent the raw values returned by the driver.
380 *
381 * @param columnIndex the first column is 1, the second is 2, ...
382 * @return the column value; if the value is SQL <code>NULL</code>, the
383 * value returned is <code>null</code>
384 * @exception SQLException if a database access error occurs
385 */
386 public byte[] getBytes(int columnIndex) throws SQLException {
387 String str = getString(columnIndex);
388 return (str == null || str.equals("")) ? null : Utils.hexStringToBytes(str);
389 }
390
391 /***
392 * Retrieves the value of the designated column in the current row
393 * of this <code>ResultSet</code> object as
394 * a <code>java.sql.Date</code> object in the Java programming language.
395 *
396 * @param columnIndex the first column is 1, the second is 2, ...
397 * @return the column value; if the value is SQL <code>NULL</code>, the
398 * value returned is <code>null</code>
399 * @exception SQLException if a database access error occurs
400 */
401 public Date getDate(int columnIndex) throws SQLException {
402 String str = getString(columnIndex);
403 return (str == null) ? null : Date.valueOf(str);
404 }
405
406 /***
407 * Retrieves the value of the designated column in the current row
408 * of this <code>ResultSet</code> object as
409 * a <code>java.sql.Time</code> object in the Java programming language.
410 *
411 * @param columnIndex the first column is 1, the second is 2, ...
412 * @return the column value; if the value is SQL <code>NULL</code>, the
413 * value returned is <code>null</code>
414 * @exception SQLException if a database access error occurs
415 */
416 public Time getTime(int columnIndex) throws SQLException {
417 String str = getString(columnIndex);
418 return (str == null) ? null : Time.valueOf(str);
419 }
420
421 /***
422 * Retrieves the value of the designated column in the current row
423 * of this <code>ResultSet</code> object as a
424 * <code>java.sql.Timestamp</code> object in the Java programming language.
425 *
426 * @param columnIndex the first column is 1, the second is 2, ...
427 * @return the column value; if the value is SQL <code>NULL</code>, the
428 * value returned is <code>null</code>
429 * @exception SQLException if a database access error occurs
430 */
431 public Timestamp getTimestamp(int columnIndex) throws SQLException {
432 String str = getString(columnIndex);
433 return (str == null) ? null : Timestamp.valueOf(str);
434 }
435
436 /***
437 * Retrieves the value of the designated column in the current row
438 * of this <code>ResultSet</code> object as a stream of ASCII characters.
439 * The value can then be read in chunks from the stream. This method is
440 * particularly suitable for retrieving large <char>LONGVARCHAR</char>
441 * values. The JDBC driver will do any necessary conversion from the
442 * database format into ASCII.
443 *
444 * <P><B>Note:</B> All the data in the returned stream must be
445 * read prior to getting the value of any other column. The next
446 * call to a getter method implicitly closes the stream. Also, a
447 * stream may return <code>0</code> when the method
448 * <code>InputStream.available</code>
449 * is called whether there is data available or not.
450 *
451 * @param columnIndex the first column is 1, the second is 2, ...
452 * @return a Java input stream that delivers the database column value
453 * as a stream of one-byte ASCII characters;
454 * if the value is SQL <code>NULL</code>, the
455 * value returned is <code>null</code>
456 * @exception SQLException if a database access error occurs
457 */
458 public InputStream getAsciiStream(int columnIndex) throws SQLException {
459 String str = getString(columnIndex);
460 is = new ByteArrayInputStream(str.getBytes());
461 return (str == null) ? null : is;
462 }
463
464 /***
465 * Retrieves the value of the designated column in the current row
466 * of this <code>ResultSet</code> object as
467 * as a stream of two-byte Unicode characters. The first byte is
468 * the high byte; the second byte is the low byte.
469 *
470 * The value can then be read in chunks from the
471 * stream. This method is particularly
472 * suitable for retrieving large <code>LONGVARCHAR</code>values. The
473 * JDBC driver will do any necessary conversion from the database
474 * format into Unicode.
475 *
476 * <P><B>Note:</B> All the data in the returned stream must be
477 * read prior to getting the value of any other column. The next
478 * call to a getter method implicitly closes the stream.
479 * Also, a stream may return <code>0</code> when the method
480 * <code>InputStream.available</code>
481 * is called, whether there is data available or not.
482 *
483 * @param columnIndex the first column is 1, the second is 2, ...
484 * @return a Java input stream that delivers the database column value
485 * as a stream of two-byte Unicode characters;
486 * if the value is SQL <code>NULL</code>, the value returned is
487 * <code>null</code>
488 *
489 * @exception SQLException if a database access error occurs
490 * @deprecated use <code>getCharacterStream</code> in place of
491 * <code>getUnicodeStream</code>
492 */
493 public InputStream getUnicodeStream(int columnIndex) throws SQLException {
494 // delegate to getAsciiStream(int)
495 return getAsciiStream(columnIndex);
496 }
497
498 /***
499 * Retrieves the value of the designated column in the current row
500 * of this <code>ResultSet</code> object as a binary stream of
501 * uninterpreted bytes. The value can then be read in chunks from the
502 * stream. This method is particularly
503 * suitable for retrieving large <code>LONGVARBINARY</code> values.
504 *
505 * <P><B>Note:</B> All the data in the returned stream must be
506 * read prior to getting the value of any other column. The next
507 * call to a getter method implicitly closes the stream. Also, a
508 * stream may return <code>0</code> when the method
509 * <code>InputStream.available</code>
510 * is called whether there is data available or not.
511 *
512 * @param columnIndex the first column is 1, the second is 2, ...
513 * @return a Java input stream that delivers the database column value
514 * as a stream of uninterpreted bytes;
515 * if the value is SQL <code>NULL</code>, the value returned is
516 * <code>null</code>
517 * @exception SQLException if a database access error occurs
518 */
519 public InputStream getBinaryStream(int columnIndex) throws SQLException {
520 // delegate to getAsciiStream(int)
521 return getAsciiStream(columnIndex);
522 }
523
524 //======================================================================
525 // Methods for accessing results by column name
526 //======================================================================
527
528 /***
529 * Retrieves the value of the designated column in the current row
530 * of this <code>ResultSet</code> object as
531 * a <code>String</code> in the Java programming language.
532 *
533 * @param columnName the SQL name of the column
534 * @return the column value; if the value is SQL <code>NULL</code>, the
535 * value returned is <code>null</code>
536 * @exception SQLException if a database access error occurs
537 */
538 public String getString(String columnName) throws SQLException {
539 // perform pre-accessor method processing
540 preAccessor(columnName);
541 String colName = this.connection.getNameColumn();
542 String colValue = this.connection.getValueColumn();
543 String retValue = "";
544 if (columnName.equalsIgnoreCase(colName)) {
545 retValue = this.currKey;
546 } else if (columnName.equalsIgnoreCase(colValue)) {
547 retValue = properties.getProperty(this.currKey);
548 }
549 return retValue;
550 }
551
552 /***
553 * Retrieves the value of the designated column in the current row
554 * of this <code>ResultSet</code> object as
555 * a <code>boolean</code> in the Java programming language.
556 *
557 * @param columnName the SQL name of the column
558 * @return the column value; if the value is SQL <code>NULL</code>, the
559 * value returned is <code>false</code>
560 * @exception SQLException if a database access error occurs
561 */
562 public boolean getBoolean(String columnName) throws SQLException {
563 String str = getString(columnName);
564 return (str == null) ? false : Boolean.valueOf(str).booleanValue();
565 }
566
567 /***
568 * Retrieves the value of the designated column in the current row
569 * of this <code>ResultSet</code> object as
570 * a <code>byte</code> in the Java programming language.
571 *
572 * @param columnName the SQL name of the column
573 * @return the column value; if the value is SQL <code>NULL</code>, the
574 * value returned is <code>0</code>
575 * @exception SQLException if a database access error occurs
576 */
577 public byte getByte(String columnName) throws SQLException {
578 String str = getString(columnName);
579 return (str == null) ? 0 : Byte.parseByte(str);
580 }
581
582 /***
583 * Retrieves the value of the designated column in the current row
584 * of this <code>ResultSet</code> object as
585 * a <code>short</code> in the Java programming language.
586 *
587 * @param columnName the SQL name of the column
588 * @return the column value; if the value is SQL <code>NULL</code>, the
589 * value returned is <code>0</code>
590 * @exception SQLException if a database access error occurs
591 */
592 public short getShort(String columnName) throws SQLException {
593 String str = getString(columnName);
594 return (str == null) ? 0 : Short.parseShort(str);
595 }
596
597 /***
598 * Gets the value of the designated column in the current row
599 * of this <code>ResultSet</code> object as
600 * an <code>int</code> in the Java programming language.
601 *
602 * @param columnName the SQL name of the column
603 * @return the column value; if the value is SQL <code>NULL</code>, the
604 * value returned is <code>0</code>
605 * @exception SQLException if a database access error occurs
606 */
607 public int getInt(String columnName) throws SQLException {
608 String str = getString(columnName);
609 return (str == null) ? 0 : Integer.parseInt(str);
610 }
611
612 /***
613 * Retrieves the value of the designated column in the current row
614 * of this <code>ResultSet</code> object as
615 * a <code>long</code> in the Java programming language.
616 *
617 * @param columnName the SQL name of the column
618 * @return the column value; if the value is SQL <code>NULL</code>, the
619 * value returned is <code>0</code>
620 * @exception SQLException if a database access error occurs
621 */
622 public long getLong(String columnName) throws SQLException {
623 String str = getString(columnName);
624 return (str == null) ? 0L : Long.parseLong(str);
625 }
626
627 /***
628 * Gets the value of the designated column in the current row
629 * of this <code>ResultSet</code> object as
630 * a <code>float</code> in the Java programming language.
631 *
632 * @param columnName the SQL name of the column
633 * @return the column value; if the value is SQL <code>NULL</code>, the
634 * value returned is <code>0</code>
635 * @exception SQLException if a database access error occurs
636 */
637 public float getFloat(String columnName) throws SQLException {
638 String str = getString(columnName);
639 return (str == null) ? 0F : Float.parseFloat(str);
640 }
641
642 /***
643 * Retrieves the value of the designated column in the current row
644 * of this <code>ResultSet</code> object as
645 * a <code>double</code> in the Java programming language.
646 *
647 * @param columnName the SQL name of the column
648 * @return the column value; if the value is SQL <code>NULL</code>, the
649 * value returned is <code>0</code>
650 * @exception SQLException if a database access error occurs
651 */
652 public double getDouble(String columnName) throws SQLException {
653 String str = getString(columnName);
654 return (str == null) ? 0D : Double.parseDouble(str);
655 }
656
657 /***
658 * Retrieves the value of the designated column in the current row
659 * of this <code>ResultSet</code> object as
660 * a <code>java.math.BigDecimal</code> in the Java programming language.
661 *
662 * @param columnName the SQL name of the column
663 * @param scale the number of digits to the right of the decimal point
664 * @return the column value; if the value is SQL <code>NULL</code>, the
665 * value returned is <code>null</code>
666 * @exception SQLException if a database access error occurs
667 * @deprecated
668 */
669 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
670 // let getBigDecimal(String) handle this for now
671 return getBigDecimal(columnName);
672 }
673
674 /***
675 * Retrieves the value of the designated column in the current row
676 * of this <code>ResultSet</code> object as
677 * a <code>byte</code> array in the Java programming language.
678 * The bytes represent the raw values returned by the driver.
679 *
680 * @param columnName the SQL name of the column
681 * @return the column value; if the value is SQL <code>NULL</code>, the
682 * value returned is <code>null</code>
683 * @exception SQLException if a database access error occurs
684 */
685 public byte[] getBytes(String columnName) throws SQLException {
686 String str = getString(columnName);
687 return (str == null) ? null : Utils.hexStringToBytes(str);
688 }
689
690 /***
691 * Retrieves the value of the designated column in the current row
692 * of this <code>ResultSet</code> object as
693 * a <code>java.sql.Date</code> object in the Java programming language.
694 *
695 * @param columnName the SQL name of the column
696 * @return the column value; if the value is SQL <code>NULL</code>, the
697 * value returned is <code>null</code>
698 * @exception SQLException if a database access error occurs
699 */
700 public Date getDate(String columnName) throws SQLException {
701 String str = getString(columnName);
702 return (str == null) ? null : Date.valueOf(str);
703 }
704
705 /***
706 * Retrieves the value of the designated column in the current row
707 * of this <code>ResultSet</code> object as
708 * a <code>java.sql.Time</code> object in the Java programming language.
709 *
710 * @param columnName the SQL name of the column
711 * @return the column value;
712 * if the value is SQL <code>NULL</code>,
713 * the value returned is <code>null</code>
714 * @exception SQLException if a database access error occurs
715 */
716 public Time getTime(String columnName) throws SQLException {
717 String str = getString(columnName);
718 return (str == null) ? null : Time.valueOf(str);
719 }
720
721 /***
722 * Retrieves the value of the designated column in the current row
723 * of this <code>ResultSet</code> object as
724 * a <code>java.sql.Timestamp</code> object.
725 *
726 * @param columnName the SQL name of the column
727 * @return the column value; if the value is SQL <code>NULL</code>, the
728 * value returned is <code>null</code>
729 * @exception SQLException if a database access error occurs
730 */
731 public Timestamp getTimestamp(String columnName) throws SQLException {
732 String str = getString(columnName);
733 return (str == null) ? null : Timestamp.valueOf(str);
734 }
735
736 /***
737 * Retrieves the value of the designated column in the current row
738 * of this <code>ResultSet</code> object as a stream of
739 * ASCII characters. The value can then be read in chunks from the
740 * stream. This method is particularly
741 * suitable for retrieving large <code>LONGVARCHAR</code> values.
742 * The JDBC driver will
743 * do any necessary conversion from the database format into ASCII.
744 *
745 * <P><B>Note:</B> All the data in the returned stream must be
746 * read prior to getting the value of any other column. The next
747 * call to a getter method implicitly closes the stream. Also, a
748 * stream may return <code>0</code> when the method <code>available</code>
749 * is called whether there is data available or not.
750 *
751 * @param columnName the SQL name of the column
752 * @return a Java input stream that delivers the database column value
753 * as a stream of one-byte ASCII characters.
754 * If the value is SQL <code>NULL</code>,
755 * the value returned is <code>null</code>.
756 * @exception SQLException if a database access error occurs
757 */
758 public InputStream getAsciiStream(String columnName) throws SQLException {
759 String str = getString(columnName);
760 is = new ByteArrayInputStream(str.getBytes());
761 return (str == null) ? null : is;
762 }
763
764 /***
765 * Retrieves the value of the designated column in the current row
766 * of this <code>ResultSet</code> object as a stream of two-byte
767 * Unicode characters. The first byte is the high byte; the second
768 * byte is the low byte.
769 *
770 * The value can then be read in chunks from the
771 * stream. This method is particularly
772 * suitable for retrieving large <code>LONGVARCHAR</code> values.
773 * The JDBC technology-enabled driver will
774 * do any necessary conversion from the database format into Unicode.
775 *
776 * <P><B>Note:</B> All the data in the returned stream must be
777 * read prior to getting the value of any other column. The next
778 * call to a getter method implicitly closes the stream.
779 * Also, a stream may return <code>0</code> when the method
780 * <code>InputStream.available</code> is called, whether there
781 * is data available or not.
782 *
783 * @param columnName the SQL name of the column
784 * @return a Java input stream that delivers the database column value
785 * as a stream of two-byte Unicode characters.
786 * If the value is SQL <code>NULL</code>, the value returned
787 * is <code>null</code>.
788 * @exception SQLException if a database access error occurs
789 * @deprecated use <code>getCharacterStream</code> instead
790 */
791 public InputStream getUnicodeStream(String columnName) throws SQLException {
792 // delegate to getAsciiStream(String)
793 return getAsciiStream(columnName);
794 }
795
796 /***
797 * Retrieves the value of the designated column in the current row
798 * of this <code>ResultSet</code> object as a stream of uninterpreted
799 * <code>byte</code>s.
800 * The value can then be read in chunks from the
801 * stream. This method is particularly
802 * suitable for retrieving large <code>LONGVARBINARY</code>
803 * values.
804 *
805 * <P><B>Note:</B> All the data in the returned stream must be
806 * read prior to getting the value of any other column. The next
807 * call to a getter method implicitly closes the stream. Also, a
808 * stream may return <code>0</code> when the method <code>available</code>
809 * is called whether there is data available or not.
810 *
811 * @param columnName the SQL name of the column
812 * @return a Java input stream that delivers the database column value
813 * as a stream of uninterpreted bytes;
814 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
815 * @exception SQLException if a database access error occurs
816 */
817 public InputStream getBinaryStream(String columnName) throws SQLException {
818 // delegate to getAsciiStream(String)
819 return getAsciiStream(columnName);
820 }
821
822 //=====================================================================
823 // Advanced features:
824 //=====================================================================
825
826 /***
827 * Retrieves the first warning reported by calls on this
828 * <code>ResultSet</code> object.
829 * Subsequent warnings on this <code>ResultSet</code> object
830 * will be chained to the <code>SQLWarning</code> object that
831 * this method returns.
832 *
833 * <P>The warning chain is automatically cleared each time a new
834 * row is read. This method may not be called on a <code>ResultSet</code>
835 * object that has been closed; doing so will cause an
836 * <code>SQLException</code> to be thrown.
837 * <P>
838 * <B>Note:</B> This warning chain only covers warnings caused
839 * by <code>ResultSet</code> methods. Any warning caused by
840 * <code>Statement</code> methods
841 * (such as reading OUT parameters) will be chained on the
842 * <code>Statement</code> object.
843 *
844 * @return the first <code>SQLWarning</code> object reported or
845 * <code>null</code> if there are none
846 * @exception SQLException if a database access error occurs or this method
847 * is called on a closed result set
848 */
849 public SQLWarning getWarnings() throws SQLException {
850 throw new UnsupportedOperationException("ResultSet.getWarnings() unsupported");
851 }
852
853 /***
854 * Clears all warnings reported on this <code>ResultSet</code> object.
855 * After this method is called, the method <code>getWarnings</code>
856 * returns <code>null</code> until a new warning is
857 * reported for this <code>ResultSet</code> object.
858 *
859 * @exception SQLException if a database access error occurs
860 */
861 public void clearWarnings() throws SQLException {
862 throw new UnsupportedOperationException("ResultSet.clearWarnings() unsupported");
863 }
864
865 /***
866 * Retrieves the name of the SQL cursor used by this <code>ResultSet</code>
867 * object.
868 *
869 * <P>In SQL, a result table is retrieved through a cursor that is
870 * named. The current row of a result set can be updated or deleted
871 * using a positioned update/delete statement that references the
872 * cursor name. To insure that the cursor has the proper isolation
873 * level to support update, the cursor's <code>SELECT</code> statement
874 * should be of the form <code>SELECT FOR UPDATE</code>. If
875 * <code>FOR UPDATE</code> is omitted, the positioned updates may fail.
876 *
877 * <P>The JDBC API supports this SQL feature by providing the name of the
878 * SQL cursor used by a <code>ResultSet</code> object.
879 * The current row of a <code>ResultSet</code> object
880 * is also the current row of this SQL cursor.
881 *
882 * <P><B>Note:</B> If positioned update is not supported, a
883 * <code>SQLException</code> is thrown.
884 *
885 * @return the SQL name for this <code>ResultSet</code> object's cursor
886 * @exception SQLException if a database access error occurs
887 */
888 public String getCursorName() throws SQLException {
889 throw new UnsupportedOperationException("ResultSet.getCursorName() unsupported");
890 }
891
892 /***
893 * Retrieves the number, types and properties of
894 * this <code>ResultSet</code> object's columns.
895 *
896 * @return the description of this <code>ResultSet</code> object's columns
897 * @exception SQLException if a database access error occurs
898 */
899 public ResultSetMetaData getMetaData() throws SQLException {
900 if (resultSetMetaData == null) {
901 resultSetMetaData = new I18nResultSetMetaData(tableName, columnNames, columnTypes);
902 }
903 return resultSetMetaData;
904 }
905
906 /***
907 * <p>Gets the value of the designated column in the current row
908 * of this <code>ResultSet</code> object as
909 * an <code>Object</code> in the Java programming language.
910 *
911 * <p>This method will return the value of the given column as a
912 * Java object. The type of the Java object will be the default
913 * Java object type corresponding to the column's SQL type,
914 * following the mapping for built-in types specified in the JDBC
915 * specification. If the value is an SQL <code>NULL</code>,
916 * the driver returns a Java <code>null</code>.
917 *
918 * <p>This method may also be used to read datatabase-specific
919 * abstract data types.
920 *
921 * In the JDBC 2.0 API, the behavior of method
922 * <code>getObject</code> is extended to materialize
923 * data of SQL user-defined types. When a column contains
924 * a structured or distinct value, the behavior of this method is as
925 * if it were a call to: <code>getObject(columnIndex,
926 * this.getStatement().getConnection().getTypeMap())</code>.
927 *
928 * @param columnIndex the first column is 1, the second is 2, ...
929 * @return a <code>java.lang.Object</code> holding the column value
930 * @exception SQLException if a database access error occurs
931 */
932 public Object getObject(int columnIndex) throws SQLException {
933 // throw new UnsupportedOperationException(
934 // "ResultSet.getObject(int) unsupported");
935 return getString(columnIndex);
936 }
937 /***
938 * <p>Gets the value of the designated column in the current row
939 * of this <code>ResultSet</code> object as
940 * an <code>Object</code> in the Java programming language.
941 *
942 * <p>This method will return the value of the given column as a
943 * Java object. The type of the Java object will be the default
944 * Java object type corresponding to the column's SQL type,
945 * following the mapping for built-in types specified in the JDBC
946 * specification. If the value is an SQL <code>NULL</code>,
947 * the driver returns a Java <code>null</code>.
948 * <P>
949 * This method may also be used to read datatabase-specific
950 * abstract data types.
951 * <P>
952 * In the JDBC 2.0 API, the behavior of the method
953 * <code>getObject</code> is extended to materialize
954 * data of SQL user-defined types. When a column contains
955 * a structured or distinct value, the behavior of this method is as
956 * if it were a call to: <code>getObject(columnIndex,
957 * this.getStatement().getConnection().getTypeMap())</code>.
958 *
959 * @param columnName the SQL name of the column
960 * @return a <code>java.lang.Object</code> holding the column value
961 * @exception SQLException if a database access error occurs
962 */
963 public Object getObject(String columnName) throws SQLException {
964 return getString(columnName);
965 }
966
967 /***
968 * Maps the given <code>ResultSet</code> column name to its
969 * <code>ResultSet</code> column index.
970 *
971 * @param columnName the name of the column
972 * @return the column index of the given column name
973 * @exception SQLException if the <code>ResultSet</code> object does
974 * not contain <code>columnName</code> or a database access error occurs
975 */
976 public int findColumn(String columnName) throws SQLException {
977 int index = -1;
978 for (int i = 0; i < this.columnNames.length; i++) {
979 if (this.columnNames[i].equalsIgnoreCase(columnName)) {
980 index = i + 1;
981 break;
982 }
983 }
984 if (index == -1)
985 throw new SQLException("Column " + columnName + " does not exist in result set!");
986 return index;
987 }
988
989 //--------------------------JDBC 2.0-----------------------------------
990
991 //---------------------------------------------------------------------
992 // Getters and Setters
993 //---------------------------------------------------------------------
994
995 /***
996 * Retrieves the value of the designated column in the current row
997 * of this <code>ResultSet</code> object as a
998 * <code>java.io.Reader</code> object.
999 *
1000 * @param columnIndex the first column is 1, the second is 2, ...
1001 * @return a <code>java.io.Reader</code> object that contains the column
1002 * value; if the value is SQL <code>NULL</code>, the value returned is
1003 * <code>null</code> in the Java programming language.
1004 * @exception SQLException if a database access error occurs
1005 */
1006 public Reader getCharacterStream(int columnIndex) throws SQLException {
1007 String str = getString(columnIndex);
1008 return (str == null) ? null : new StringReader(str);
1009 }
1010
1011 /***
1012 * Retrieves the value of the designated column in the current row
1013 * of this <code>ResultSet</code> object as a
1014 * <code>java.io.Reader</code> object.
1015 *
1016 * @param columnName the name of the column
1017 * @return a <code>java.io.Reader</code> object that contains the column
1018 * value; if the value is SQL <code>NULL</code>, the value returned is
1019 * <code>null</code> in the Java programming language
1020 * @exception SQLException if a database access error occurs
1021 */
1022 public Reader getCharacterStream(String columnName) throws SQLException {
1023 String str = getString(columnName);
1024 return (str == null) ? null : new StringReader(str);
1025 }
1026
1027 /***
1028 * Retrieves the value of the designated column in the current row
1029 * of this <code>ResultSet</code> object as a
1030 * <code>java.math.BigDecimal</code> with full precision.
1031 *
1032 * @param columnIndex the first column is 1, the second is 2, ...
1033 * @return the column value (full precision);
1034 * if the value is SQL <code>NULL</code>, the value returned is
1035 * <code>null</code> in the Java programming language.
1036 * @exception SQLException if a database access error occurs
1037 */
1038 public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
1039 BigDecimal retval = null;
1040 String str = getString(columnIndex);
1041 if (str != null) {
1042 try {
1043 retval = new BigDecimal(str);
1044 } catch (NumberFormatException e) {
1045 throw new SQLException("Could not convert '" + str + "' to " + "a java.math.BigDecimal object");
1046 }
1047 }
1048 return retval;
1049 }
1050
1051 /***
1052 * Retrieves the value of the designated column in the current row
1053 * of this <code>ResultSet</code> object as a
1054 * <code>java.math.BigDecimal</code> with full precision.
1055 *
1056 * @param columnName the column name
1057 * @return the column value (full precision);
1058 * if the value is SQL <code>NULL</code>, the value returned is
1059 * <code>null</code> in the Java programming language.
1060 * @exception SQLException if a database access error occurs
1061 */
1062 public BigDecimal getBigDecimal(String columnName) throws SQLException {
1063 BigDecimal retval = null;
1064 String str = getString(columnName);
1065 if (str != null) {
1066 try {
1067 retval = new BigDecimal(str);
1068 } catch (NumberFormatException e) {
1069 throw new SQLException("Could not convert '" + str + "' to " + "a java.math.BigDecimal object");
1070 }
1071 }
1072 return retval;
1073 }
1074
1075 //---------------------------------------------------------------------
1076 // Traversal/Positioning
1077 //---------------------------------------------------------------------
1078
1079 /***
1080 * Retrieves whether the cursor is before the first row in
1081 * this <code>ResultSet</code> object.
1082 *
1083 * @return <code>true</code> if the cursor is before the first row;
1084 * <code>false</code> if the cursor is at any other position or the
1085 * result set contains no rows
1086 * @exception SQLException if a database access error occurs
1087 */
1088 public boolean isBeforeFirst() throws SQLException {
1089 throw new UnsupportedOperationException("ResultSet.isBeforeFirst() unsupported");
1090 }
1091
1092 /***
1093 * Retrieves whether the cursor is after the last row in
1094 * this <code>ResultSet</code> object.
1095 *
1096 * @return <code>true</code> if the cursor is after the last row;
1097 * <code>false</code> if the cursor is at any other position or the
1098 * result set contains no rows
1099 * @exception SQLException if a database access error occurs
1100 */
1101 public boolean isAfterLast() throws SQLException {
1102 throw new UnsupportedOperationException("ResultSet.isAfterLast() unsupported");
1103 }
1104
1105 /***
1106 * Retrieves whether the cursor is on the first row of
1107 * this <code>ResultSet</code> object.
1108 *
1109 * @return <code>true</code> if the cursor is on the first row;
1110 * <code>false</code> otherwise
1111 * @exception SQLException if a database access error occurs
1112 */
1113 public boolean isFirst() throws SQLException {
1114 throw new UnsupportedOperationException("ResultSet.isFirst() unsupported");
1115 }
1116
1117 /***
1118 * Retrieves whether the cursor is on the last row of
1119 * this <code>ResultSet</code> object.
1120 * Note: Calling the method <code>isLast</code> may be expensive
1121 * because the JDBC driver
1122 * might need to fetch ahead one row in order to determine
1123 * whether the current row is the last row in the result set.
1124 *
1125 * @return <code>true</code> if the cursor is on the last row;
1126 * <code>false</code> otherwise
1127 * @exception SQLException if a database access error occurs
1128 */
1129 public boolean isLast() throws SQLException {
1130 throw new UnsupportedOperationException("ResultSet.isLast() unsupported");
1131 }
1132
1133 /***
1134 * Moves the cursor to the front of
1135 * this <code>ResultSet</code> object, just before the
1136 * first row. This method has no effect if the result set contains no rows.
1137 *
1138 * @exception SQLException if a database access error
1139 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1140 */
1141 public void beforeFirst() throws SQLException {
1142 throw new UnsupportedOperationException("ResultSet.beforeFirst() unsupported");
1143 }
1144
1145 /***
1146 * Moves the cursor to the end of
1147 * this <code>ResultSet</code> object, just after the
1148 * last row. This method has no effect if the result set contains no rows.
1149 * @exception SQLException if a database access error
1150 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1151 */
1152 public void afterLast() throws SQLException {
1153 throw new UnsupportedOperationException("ResultSet.afterLast() unsupported");
1154 }
1155
1156 /***
1157 * Moves the cursor to the first row in
1158 * this <code>ResultSet</code> object.
1159 *
1160 * @return <code>true</code> if the cursor is on a valid row;
1161 * <code>false</code> if there are no rows in the result set
1162 * @exception SQLException if a database access error
1163 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1164 */
1165 public boolean first() throws SQLException {
1166 throw new UnsupportedOperationException("ResultSet.first() unsupported");
1167 }
1168
1169 /***
1170 * Moves the cursor to the last row in
1171 * this <code>ResultSet</code> object.
1172 *
1173 * @return <code>true</code> if the cursor is on a valid row;
1174 * <code>false</code> if there are no rows in the result set
1175 * @exception SQLException if a database access error
1176 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1177 */
1178 public boolean last() throws SQLException {
1179 throw new UnsupportedOperationException("ResultSet.last() unsupported");
1180 }
1181
1182 /***
1183 * Retrieves the current row number. The first row is number 1, the
1184 * second number 2, and so on.
1185 *
1186 * @return the current row number; <code>0</code> if there is no current row
1187 * @exception SQLException if a database access error occurs
1188 */
1189 public int getRow() throws SQLException {
1190 throw new UnsupportedOperationException("ResultSet.getRow() unsupported");
1191 }
1192
1193 /***
1194 * Moves the cursor to the given row number in
1195 * this <code>ResultSet</code> object.
1196 *
1197 * <p>If the row number is positive, the cursor moves to
1198 * the given row number with respect to the
1199 * beginning of the result set. The first row is row 1, the second
1200 * is row 2, and so on.
1201 *
1202 * <p>If the given row number is negative, the cursor moves to
1203 * an absolute row position with respect to
1204 * the end of the result set. For example, calling the method
1205 * <code>absolute(-1)</code> positions the
1206 * cursor on the last row; calling the method <code>absolute(-2)</code>
1207 * moves the cursor to the next-to-last row, and so on.
1208 *
1209 * <p>An attempt to position the cursor beyond the first/last row in
1210 * the result set leaves the cursor before the first row or after
1211 * the last row.
1212 *
1213 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
1214 * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
1215 * is the same as calling <code>last()</code>.
1216 *
1217 * @param row the number of the row to which the cursor should move.
1218 * A positive number indicates the row number counting from the
1219 * beginning of the result set; a negative number indicates the
1220 * row number counting from the end of the result set
1221 * @return <code>true</code> if the cursor is on the result set;
1222 * <code>false</code> otherwise
1223 * @exception SQLException if a database access error
1224 * occurs, or the result set type is <code>TYPE_FORWARD_ONLY</code>
1225 */
1226 public boolean absolute(int row) throws SQLException {
1227 throw new UnsupportedOperationException("ResultSet.absolute() unsupported");
1228 }
1229
1230 /***
1231 * Moves the cursor a relative number of rows, either positive or negative.
1232 * Attempting to move beyond the first/last row in the
1233 * result set positions the cursor before/after the
1234 * the first/last row. Calling <code>relative(0)</code> is valid, but does
1235 * not change the cursor position.
1236 *
1237 * <p>Note: Calling the method <code>relative(1)</code>
1238 * is identical to calling the method <code>next()</code> and
1239 * calling the method <code>relative(-1)</code> is identical
1240 * to calling the method <code>previous()</code>.
1241 *
1242 * @param rows an <code>int</code> specifying the number of rows to
1243 * move from the current row; a positive number moves the cursor
1244 * forward; a negative number moves the cursor backward
1245 * @return <code>true</code> if the cursor is on a row;
1246 * <code>false</code> otherwise
1247 * @exception SQLException if a database access error occurs,
1248 * there is no current row, or the result set type is
1249 * <code>TYPE_FORWARD_ONLY</code>
1250 */
1251 public boolean relative(int rows) throws SQLException {
1252 throw new UnsupportedOperationException("ResultSet.relative() unsupported");
1253 }
1254
1255 /***
1256 * Moves the cursor to the previous row in this
1257 * <code>ResultSet</code> object.
1258 *
1259 * @return <code>true</code> if the cursor is on a valid row;
1260 * <code>false</code> if it is off the result set
1261 * @exception SQLException if a database access error
1262 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1263 */
1264 public boolean previous() throws SQLException {
1265 throw new UnsupportedOperationException("ResultSet.previous() unsupported");
1266 }
1267
1268 //---------------------------------------------------------------------
1269 // Properties
1270 //---------------------------------------------------------------------
1271
1272 /***
1273 * Gives a hint as to the direction in which the rows in this
1274 * <code>ResultSet</code> object will be processed. The initial value is
1275 * determined by the <code>Statement</code> object that produced this
1276 * <code>ResultSet</code> object. The fetch direction may be changed at
1277 * any time.
1278 *
1279 * @param direction an <code>int</code> specifying the suggested
1280 * fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>,
1281 * <code>ResultSet.FETCH_REVERSE</code>, or
1282 * <code>ResultSet.FETCH_UNKNOWN</code>
1283 * @exception SQLException if a database access error occurs or
1284 * the result set type is <code>TYPE_FORWARD_ONLY</code>
1285 * and the fetch direction is not <code>FETCH_FORWARD</code>
1286 */
1287 public void setFetchDirection(int direction) throws SQLException {
1288 throw new UnsupportedOperationException("ResultSet.setFetchDirection(int) unsupported");
1289 }
1290
1291 /***
1292 * Retrieves the fetch direction for this
1293 * <code>ResultSet</code> object.
1294 *
1295 * @return the current fetch direction for this <code>ResultSet</code>
1296 * object
1297 * @exception SQLException if a database access error occurs
1298 * @see #setFetchDirection
1299 */
1300 public int getFetchDirection() throws SQLException {
1301 throw new UnsupportedOperationException("ResultSet.getFetchDirection() unsupported");
1302 }
1303
1304 /***
1305 * Gives the JDBC driver a hint as to the number of rows that should
1306 * be fetched from the database when more rows are needed for this
1307 * <code>ResultSet</code> object. If the fetch size specified is zero,
1308 * the JDBC driver ignores the value and is free to make its own best
1309 * guess as to what the fetch size should be. The default value is set
1310 * by the <code>Statement</code> object that created the result set.
1311 * The fetch size may be changed at any time.
1312 *
1313 * @param rows the number of rows to fetch
1314 * @exception SQLException if a database access error occurs or the
1315 * condition <code>0 <= rows <= this.getMaxRows()</code> is not satisfied
1316 */
1317 public void setFetchSize(int rows) throws SQLException {
1318 throw new UnsupportedOperationException("ResultSet.setFetchSize(int) unsupported");
1319 }
1320
1321 /***
1322 * Retrieves the fetch size for this
1323 * <code>ResultSet</code> object.
1324 *
1325 * @return the current fetch size for this <code>ResultSet</code> object
1326 * @exception SQLException if a database access error occurs
1327 * @see #setFetchSize
1328 */
1329 public int getFetchSize() throws SQLException {
1330 throw new UnsupportedOperationException("ResultSet.getFetchSize() unsupported");
1331 }
1332
1333 /***
1334 * Retrieves the type of this <code>ResultSet</code> object.
1335 * The type is determined by the <code>Statement</code> object
1336 * that created the result set.
1337 *
1338 * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
1339 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
1340 * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
1341 * @exception SQLException if a database access error occurs
1342 */
1343 public int getType() throws SQLException {
1344 throw new UnsupportedOperationException("ResultSet.getType() unsupported");
1345 }
1346
1347 /***
1348 * Retrieves the concurrency mode of this <code>ResultSet</code> object.
1349 * The concurrency used is determined by the
1350 * <code>Statement</code> object that created the result set.
1351 *
1352 * @return the concurrency type, either
1353 * <code>ResultSet.CONCUR_READ_ONLY</code>
1354 * or <code>ResultSet.CONCUR_UPDATABLE</code>
1355 * @exception SQLException if a database access error occurs
1356 */
1357 public int getConcurrency() throws SQLException {
1358 return CONCUR_READ_ONLY;
1359 }
1360
1361 //---------------------------------------------------------------------
1362 // Updates
1363 //---------------------------------------------------------------------
1364
1365 /***
1366 * Retrieves whether the current row has been updated. The value returned
1367 * depends on whether or not the result set can detect updates.
1368 *
1369 * @return <code>true</code> if both (1) the row has been visibly updated
1370 * by the owner or another and (2) updates are detected
1371 * @exception SQLException if a database access error occurs
1372 * @see DatabaseMetaData#updatesAreDetected
1373 */
1374 public boolean rowUpdated() throws SQLException {
1375 throw new UnsupportedOperationException("ResultSet.rowUpdated() unsupported");
1376 }
1377
1378 /***
1379 * Retrieves whether the current row has had an insertion.
1380 * The value returned depends on whether or not this
1381 * <code>ResultSet</code> object can detect visible inserts.
1382 *
1383 * @return <code>true</code> if a row has had an insertion
1384 * and insertions are detected; <code>false</code> otherwise
1385 * @exception SQLException if a database access error occurs
1386 *
1387 * @see DatabaseMetaData#insertsAreDetected
1388 */
1389 public boolean rowInserted() throws SQLException {
1390 throw new UnsupportedOperationException("ResultSet.rowInserted() unsupported");
1391 }
1392
1393 /***
1394 * Retrieves whether a row has been deleted. A deleted row may leave
1395 * a visible "hole" in a result set. This method can be used to
1396 * detect holes in a result set. The value returned depends on whether
1397 * or not this <code>ResultSet</code> object can detect deletions.
1398 *
1399 * @return <code>true</code> if a row was deleted and deletions are
1400 * detected; <code>false</code> otherwise
1401 * @exception SQLException if a database access error occurs
1402 *
1403 * @see DatabaseMetaData#deletesAreDetected
1404 */
1405 public boolean rowDeleted() throws SQLException {
1406 throw new UnsupportedOperationException("ResultSet.rowDeleted() unsupported");
1407 }
1408
1409 /***
1410 * Gives a nullable column a null value.
1411 *
1412 * The updater methods are used to update column values in the
1413 * current row or the insert row. The updater methods do not
1414 * update the underlying database; instead the <code>updateRow</code>
1415 * or <code>insertRow</code> methods are called to update the database.
1416 *
1417 * @param columnIndex the first column is 1, the second is 2, ...
1418 * @exception SQLException if a database access error occurs
1419 */
1420 public void updateNull(int columnIndex) throws SQLException {
1421 throw new UnsupportedOperationException("ResultSet.updateNull() unsupported");
1422 }
1423
1424 /***
1425 * Updates the designated column with a <code>boolean</code> value.
1426 * The updater methods are used to update column values in the
1427 * current row or the insert row. The updater methods do not
1428 * update the underlying database; instead the <code>updateRow</code> or
1429 * <code>insertRow</code> methods are called to update the database.
1430 *
1431 * @param columnIndex the first column is 1, the second is 2, ...
1432 * @param x the new column value
1433 * @exception SQLException if a database access error occurs
1434 */
1435 public void updateBoolean(int columnIndex, boolean x) throws SQLException {
1436 throw new UnsupportedOperationException("ResultSet.updateBoolean() unsupported");
1437 }
1438
1439 /***
1440 * Updates the designated column with a <code>byte</code> value.
1441 * The updater methods are used to update column values in the
1442 * current row or the insert row. The updater methods do not
1443 * update the underlying database; instead the <code>updateRow</code> or
1444 * <code>insertRow</code> methods are called to update the database.
1445 *
1446 *
1447 * @param columnIndex the first column is 1, the second is 2, ...
1448 * @param x the new column value
1449 * @exception SQLException if a database access error occurs
1450 */
1451 public void updateByte(int columnIndex, byte x) throws SQLException {
1452 throw new UnsupportedOperationException("ResultSet.updateByte() unsupported");
1453 }
1454
1455 /***
1456 * Updates the designated column with a <code>short</code> value.
1457 * The updater methods are used to update column values in the
1458 * current row or the insert row. The updater methods do not
1459 * update the underlying database; instead the <code>updateRow</code> or
1460 * <code>insertRow</code> methods are called to update the database.
1461 *
1462 * @param columnIndex the first column is 1, the second is 2, ...
1463 * @param x the new column value
1464 * @exception SQLException if a database access error occurs
1465 */
1466 public void updateShort(int columnIndex, short x) throws SQLException {
1467 throw new UnsupportedOperationException("ResultSet.updateShort() unsupported");
1468 }
1469
1470 /***
1471 * Updates the designated column with an <code>int</code> value.
1472 * The updater methods are used to update column values in the
1473 * current row or the insert row. The updater methods do not
1474 * update the underlying database; instead the <code>updateRow</code> or
1475 * <code>insertRow</code> methods are called to update the database.
1476 *
1477 * @param columnIndex the first column is 1, the second is 2, ...
1478 * @param x the new column value
1479 * @exception SQLException if a database access error occurs
1480 */
1481 public void updateInt(int columnIndex, int x) throws SQLException {
1482 throw new UnsupportedOperationException("ResultSet.updateInt() unsupported");
1483 }
1484
1485 /***
1486 * Updates the designated column with a <code>long</code> value.
1487 * The updater methods are used to update column values in the
1488 * current row or the insert row. The updater methods do not
1489 * update the underlying database; instead the <code>updateRow</code> or
1490 * <code>insertRow</code> methods are called to update the database.
1491 *
1492 * @param columnIndex the first column is 1, the second is 2, ...
1493 * @param x the new column value
1494 * @exception SQLException if a database access error occurs
1495 */
1496 public void updateLong(int columnIndex, long x) throws SQLException {
1497 throw new UnsupportedOperationException("ResultSet.updateLong(int, long) unsupported");
1498 }
1499
1500 /***
1501 * Updates the designated column with a <code>float</code> value.
1502 * The updater methods are used to update column values in the
1503 * current row or the insert row. The updater methods do not
1504 * update the underlying database; instead the <code>updateRow</code> or
1505 * <code>insertRow</code> methods are called to update the database.
1506 *
1507 * @param columnIndex the first column is 1, the second is 2, ...
1508 * @param x the new column value
1509 * @exception SQLException if a database access error occurs
1510 */
1511 public void updateFloat(int columnIndex, float x) throws SQLException {
1512 throw new UnsupportedOperationException("ResultSet.updateFloat(int, float) unsupported");
1513 }
1514
1515 /***
1516 * Updates the designated column with a <code>double</code> value.
1517 * The updater methods are used to update column values in the
1518 * current row or the insert row. The updater methods do not
1519 * update the underlying database; instead the <code>updateRow</code> or
1520 * <code>insertRow</code> methods are called to update the database.
1521 *
1522 * @param columnIndex the first column is 1, the second is 2, ...
1523 * @param x the new column value
1524 * @exception SQLException if a database access error occurs
1525 */
1526 public void updateDouble(int columnIndex, double x) throws SQLException {
1527 throw new UnsupportedOperationException("ResultSet.updateDouble(int, double) unsupported");
1528 }
1529
1530 /***
1531 * Updates the designated column with a <code>java.math.BigDecimal</code>
1532 * value.
1533 * The updater methods are used to update column values in the
1534 * current row or the insert row. The updater methods do not
1535 * update the underlying database; instead the <code>updateRow</code> or
1536 * <code>insertRow</code> methods are called to update the database.
1537 *
1538 * @param columnIndex the first column is 1, the second is 2, ...
1539 * @param x the new column value
1540 * @exception SQLException if a database access error occurs
1541 */
1542 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
1543 throw new UnsupportedOperationException("ResultSet.updateBigDecimal(int, BigDecimal) unsupported");
1544 }
1545
1546 /***
1547 * Updates the designated column with a <code>String</code> value.
1548 * The updater methods are used to update column values in the
1549 * current row or the insert row. The updater methods do not
1550 * update the underlying database; instead the <code>updateRow</code> or
1551 * <code>insertRow</code> methods are called to update the database.
1552 *
1553 * @param columnIndex the first column is 1, the second is 2, ...
1554 * @param x the new column value
1555 * @exception SQLException if a database access error occurs
1556 */
1557 public void updateString(int columnIndex, String x) throws SQLException {
1558 throw new UnsupportedOperationException("ResultSet.updateString(int, String) unsupported");
1559 }
1560
1561 /***
1562 * Updates the designated column with a <code>byte</code> array value.
1563 * The updater methods are used to update column values in the
1564 * current row or the insert row. The updater methods do not
1565 * update the underlying database; instead the <code>updateRow</code> or
1566 * <code>insertRow</code> methods are called to update the database.
1567 *
1568 * @param columnIndex the first column is 1, the second is 2, ...
1569 * @param x the new column value
1570 * @exception SQLException if a database access error occurs
1571 */
1572 public void updateBytes(int columnIndex, byte[] x) throws SQLException {
1573 throw new UnsupportedOperationException("ResultSet.updateBytes(int, byte[]) unsupported");
1574 }
1575
1576 /***
1577 * Updates the designated column with a <code>java.sql.Date</code> value.
1578 * The updater methods are used to update column values in the
1579 * current row or the insert row. The updater methods do not
1580 * update the underlying database; instead the <code>updateRow</code> or
1581 * <code>insertRow</code> methods are called to update the database.
1582 *
1583 * @param columnIndex the first column is 1, the second is 2, ...
1584 * @param x the new column value
1585 * @exception SQLException if a database access error occurs
1586 */
1587 public void updateDate(int columnIndex, Date x) throws SQLException {
1588 throw new UnsupportedOperationException("ResultSet.updateDate(int, Date) unsupported");
1589 }
1590
1591 /***
1592 * Updates the designated column with a <code>java.sql.Time</code> value.
1593 * The updater methods are used to update column values in the
1594 * current row or the insert row. The updater methods do not
1595 * update the underlying database; instead the <code>updateRow</code> or
1596 * <code>insertRow</code> methods are called to update the database.
1597 *
1598 * @param columnIndex the first column is 1, the second is 2, ...
1599 * @param x the new column value
1600 * @exception SQLException if a database access error occurs
1601 */
1602 public void updateTime(int columnIndex, Time x) throws SQLException {
1603 throw new UnsupportedOperationException("ResultSet.updateTime(int, Time) unsupported");
1604 }
1605
1606 /***
1607 * Updates the designated column with a <code>java.sql.Timestamp</code>
1608 * value.
1609 * The updater methods are used to update column values in the
1610 * current row or the insert row. The updater methods do not
1611 * update the underlying database; instead the <code>updateRow</code> or
1612 * <code>insertRow</code> methods are called to update the database.
1613 *
1614 * @param columnIndex the first column is 1, the second is 2, ...
1615 * @param x the new column value
1616 * @exception SQLException if a database access error occurs
1617 */
1618 public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
1619 throw new UnsupportedOperationException("ResultSet.updateTimestamp(int, Timestamp) unsupported");
1620 }
1621
1622 /***
1623 * Updates the designated column with an ascii stream value.
1624 * The updater methods are used to update column values in the
1625 * current row or the insert row. The updater methods do not
1626 * update the underlying database; instead the <code>updateRow</code> or
1627 * <code>insertRow</code> methods are called to update the database.
1628 *
1629 * @param columnIndex the first column is 1, the second is 2, ...
1630 * @param x the new column value
1631 * @param length the length of the stream
1632 * @exception SQLException if a database access error occurs
1633 */
1634 public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
1635 throw new UnsupportedOperationException("ResultSet.updateAsciiStream " + "(int, InputStream, int) unsupported");
1636 }
1637
1638 /***
1639 * Updates the designated column with a binary stream value.
1640 * The updater methods are used to update column values in the
1641 * current row or the insert row. The updater methods do not
1642 * update the underlying database; instead the <code>updateRow</code> or
1643 * <code>insertRow</code> methods are called to update the database.
1644 *
1645 * @param columnIndex the first column is 1, the second is 2, ...
1646 * @param x the new column value
1647 * @param length the length of the stream
1648 * @exception SQLException if a database access error occurs
1649 */
1650 public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
1651 throw new UnsupportedOperationException("ResultSet.updateBinaryStream" + "(int, InputStream, int) unsupported");
1652 }
1653
1654 /***
1655 * Updates the designated column with a character stream value.
1656 * The updater methods are used to update column values in the
1657 * current row or the insert row. The updater methods do not
1658 * update the underlying database; instead the <code>updateRow</code> or
1659 * <code>insertRow</code> methods are called to update the database.
1660 *
1661 * @param columnIndex the first column is 1, the second is 2, ...
1662 * @param x the new column value
1663 * @param length the length of the stream
1664 * @exception SQLException if a database access error occurs
1665 */
1666 public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
1667 throw new UnsupportedOperationException("ResultSet.updateCharacterStr" + "eam(int, Reader, int) unsupported");
1668 }
1669
1670 /***
1671 * Updates the designated column with an <code>Object</code> value.
1672 * The updater methods are used to update column values in the
1673 * current row or the insert row. The updater methods do not
1674 * update the underlying database; instead the <code>updateRow</code> or
1675 * <code>insertRow</code> methods are called to update the database.
1676 *
1677 * @param columnIndex the first column is 1, the second is 2, ...
1678 * @param x the new column value
1679 * @param scale for <code>java.sql.Types.DECIMA</code>
1680 * or <code>java.sql.Types.NUMERIC</code> types,
1681 * this is the number of digits after the decimal point. For all other
1682 * types this value will be ignored.
1683 * @exception SQLException if a database access error occurs
1684 */
1685 public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
1686 throw new UnsupportedOperationException("ResultSet.udpateObject(int, Object) unsupported");
1687 }
1688
1689 /***
1690 * Updates the designated column with an <code>Object</code> value.
1691 * The updater methods are used to update column values in the
1692 * current row or the insert row. The updater methods do not
1693 * update the underlying database; instead the <code>updateRow</code> or
1694 * <code>insertRow</code> methods are called to update the database.
1695 *
1696 * @param columnIndex the first column is 1, the second is 2, ...
1697 * @param x the new column value
1698 * @exception SQLException if a database access error occurs
1699 */
1700 public void updateObject(int columnIndex, Object x) throws SQLException {
1701 throw new UnsupportedOperationException("ResultSet.updateObject(int, Object, int) unsupported");
1702 }
1703
1704 /***
1705 * Updates the designated column with a <code>null</code> value.
1706 * The updater methods are used to update column values in the
1707 * current row or the insert row. The updater methods do not
1708 * update the underlying database; instead the <code>updateRow</code> or
1709 * <code>insertRow</code> methods are called to update the database.
1710 *
1711 * @param columnName the name of the column
1712 * @exception SQLException if a database access error occurs
1713 */
1714 public void updateNull(String columnName) throws SQLException {
1715 throw new UnsupportedOperationException("ResultSet.updateNull(String) unsupported");
1716 }
1717
1718 /***
1719 * Updates the designated column with a <code>boolean</code> value.
1720 * The updater methods are used to update column values in the
1721 * current row or the insert row. The updater methods do not
1722 * update the underlying database; instead the <code>updateRow</code> or
1723 * <code>insertRow</code> methods are called to update the database.
1724 *
1725 * @param columnName the name of the column
1726 * @param x the new column value
1727 * @exception SQLException if a database access error occurs
1728 */
1729 public void updateBoolean(String columnName, boolean x) throws SQLException {
1730 throw new UnsupportedOperationException("ResultSet.updateBoolean(String, boolean) unsupported");
1731 }
1732
1733 /***
1734 * Updates the designated column with a <code>byte</code> value.
1735 * The updater methods are used to update column values in the
1736 * current row or the insert row. The updater methods do not
1737 * update the underlying database; instead the <code>updateRow</code> or
1738 * <code>insertRow</code> methods are called to update the database.
1739 *
1740 * @param columnName the name of the column
1741 * @param x the new column value
1742 * @exception SQLException if a database access error occurs
1743 */
1744 public void updateByte(String columnName, byte x) throws SQLException {
1745 throw new UnsupportedOperationException("ResultSet.updateByte(String, byte) unsupported");
1746 }
1747
1748 /***
1749 * Updates the designated column with a <code>short</code> value.
1750 * The updater methods are used to update column values in the
1751 * current row or the insert row. The updater methods do not
1752 * update the underlying database; instead the <code>updateRow</code> or
1753 * <code>insertRow</code> methods are called to update the database.
1754 *
1755 * @param columnName the name of the column
1756 * @param x the new column value
1757 * @exception SQLException if a database access error occurs
1758 */
1759 public void updateShort(String columnName, short x) throws SQLException {
1760 throw new UnsupportedOperationException("ResultSet.updateShort(String, short) unsupported");
1761 }
1762
1763 /***
1764 * Updates the designated column with an <code>int</code> value.
1765 * The updater methods are used to update column values in the
1766 * current row or the insert row. The updater methods do not
1767 * update the underlying database; instead the <code>updateRow</code> or
1768 * <code>insertRow</code> methods are called to update the database.
1769 *
1770 * @param columnName the name of the column
1771 * @param x the new column value
1772 * @exception SQLException if a database access error occurs
1773 */
1774 public void updateInt(String columnName, int x) throws SQLException {
1775 throw new UnsupportedOperationException("ResultSet.updateInt(String, int) unsupported");
1776 }
1777
1778 /***
1779 * Updates the designated column with a <code>long</code> value.
1780 * The updater methods are used to update column values in the
1781 * current row or the insert row. The updater methods do not
1782 * update the underlying database; instead the <code>updateRow</code> or
1783 * <code>insertRow</code> methods are called to update the database.
1784 *
1785 * @param columnName the name of the column
1786 * @param x the new column value
1787 * @exception SQLException if a database access error occurs
1788 */
1789 public void updateLong(String columnName, long x) throws SQLException {
1790 throw new UnsupportedOperationException("ResultSet.updateLong(String, long) unsupported");
1791 }
1792
1793 /***
1794 * Updates the designated column with a <code>float </code> value.
1795 * The updater methods are used to update column values in the
1796 * current row or the insert row. The updater methods do not
1797 * update the underlying database; instead the <code>updateRow</code> or
1798 * <code>insertRow</code> methods are called to update the database.
1799 *
1800 * @param columnName the name of the column
1801 * @param x the new column value
1802 * @exception SQLException if a database access error occurs
1803 */
1804 public void updateFloat(String columnName, float x) throws SQLException {
1805 throw new UnsupportedOperationException("ResultSet.updateFloat(String, float) unsupported");
1806 }
1807
1808 /***
1809 * Updates the designated column with a <code>double</code> value.
1810 * The updater methods are used to update column values in the
1811 * current row or the insert row. The updater methods do not
1812 * update the underlying database; instead the <code>updateRow</code> or
1813 * <code>insertRow</code> methods are called to update the database.
1814 *
1815 * @param columnName the name of the column
1816 * @param x the new column value
1817 * @exception SQLException if a database access error occurs
1818 */
1819 public void updateDouble(String columnName, double x) throws SQLException {
1820 throw new UnsupportedOperationException("ResultSet.updateDouble(String, double) unsupported");
1821 }
1822
1823 /***
1824 * Updates the designated column with a <code>java.sql.BigDecimal</code>
1825 * value.
1826 * The updater methods are used to update column values in the
1827 * current row or the insert row. The updater methods do not
1828 * update the underlying database; instead the <code>updateRow</code> or
1829 * <code>insertRow</code> methods are called to update the database.
1830 *
1831 * @param columnName the name of the column
1832 * @param x the new column value
1833 * @exception SQLException if a database access error occurs
1834 */
1835 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
1836 throw new UnsupportedOperationException("ResultSet.updateBigDecimal(String, BigDecimal) unsupported");
1837 }
1838
1839 /***
1840 * Updates the designated column with a <code>String</code> value.
1841 * The updater methods are used to update column values in the
1842 * current row or the insert row. The updater methods do not
1843 * update the underlying database; instead the <code>updateRow</code> or
1844 * <code>insertRow</code> methods are called to update the database.
1845 *
1846 * @param columnName the name of the column
1847 * @param x the new column value
1848 * @exception SQLException if a database access error occurs
1849 */
1850 public void updateString(String columnName, String x) throws SQLException {
1851 throw new UnsupportedOperationException("ResultSet.updateString(String, String) unsupported");
1852 }
1853
1854 /***
1855 * Updates the designated column with a byte array value.
1856 *
1857 * The updater methods are used to update column values in the
1858 * current row or the insert row. The updater methods do not
1859 * update the underlying database; instead the <code>updateRow</code>
1860 * or <code>insertRow</code> methods are called to update the database.
1861 *
1862 * @param columnName the name of the column
1863 * @param x the new column value
1864 * @exception SQLException if a database access error occurs
1865 */
1866 public void updateBytes(String columnName, byte[] x) throws SQLException {
1867 throw new UnsupportedOperationException("ResultSet.updateBytes(String, byte[]) unsupported");
1868 }
1869
1870 /***
1871 * Updates the designated column with a <code>java.sql.Date</code> value.
1872 * The updater methods are used to update column values in the
1873 * current row or the insert row. The updater methods do not
1874 * update the underlying database; instead the <code>updateRow</code> or
1875 * <code>insertRow</code> methods are called to update the database.
1876 *
1877 * @param columnName the name of the column
1878 * @param x the new column value
1879 * @exception SQLException if a database access error occurs
1880 */
1881 public void updateDate(String columnName, Date x) throws SQLException {
1882 throw new UnsupportedOperationException("ResultSet.updateDate(String, Date) unsupported");
1883 }
1884
1885 /***
1886 * Updates the designated column with a <code>java.sql.Time</code> value.
1887 * The updater methods are used to update column values in the
1888 * current row or the insert row. The updater methods do not
1889 * update the underlying database; instead the <code>updateRow</code> or
1890 * <code>insertRow</code> methods are called to update the database.
1891 *
1892 * @param columnName the name of the column
1893 * @param x the new column value
1894 * @exception SQLException if a database access error occurs
1895 */
1896 public void updateTime(String columnName, Time x) throws SQLException {
1897 throw new UnsupportedOperationException("ResultSet.updateTime(String, Time) unsupported");
1898 }
1899
1900 /***
1901 * Updates the designated column with a <code>java.sql.Timestamp</code>
1902 * value.
1903 * The updater methods are used to update column values in the
1904 * current row or the insert row. The updater methods do not
1905 * update the underlying database; instead the <code>updateRow</code> or
1906 * <code>insertRow</code> methods are called to update the database.
1907 *
1908 * @param columnName the name of the column
1909 * @param x the new column value
1910 * @exception SQLException if a database access error occurs
1911 */
1912 public void updateTimestamp(String columnName, Timestamp x) throws SQLException {
1913 throw new UnsupportedOperationException("ResultSet.updateTimestamp(String, Timestamp) unsupported");
1914 }
1915
1916 /***
1917 * Updates the designated column with an ascii stream value.
1918 * The updater methods are used to update column values in the
1919 * current row or the insert row. The updater methods do not
1920 * update the underlying database; instead the <code>updateRow</code> or
1921 * <code>insertRow</code> methods are called to update the database.
1922 *
1923 * @param columnName the name of the column
1924 * @param x the new column value
1925 * @param length the length of the stream
1926 * @exception SQLException if a database access error occurs
1927 */
1928 public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException {
1929 throw new UnsupportedOperationException("ResultSet.updateAsciiStream" + "(String, InputStream, int) unsupported");
1930 }
1931
1932 /***
1933 * Updates the designated column with a binary stream value.
1934 * The updater methods are used to update column values in the
1935 * current row or the insert row. The updater methods do not
1936 * update the underlying database; instead the <code>updateRow</code> or
1937 * <code>insertRow</code> methods are called to update the database.
1938 *
1939 * @param columnName the name of the column
1940 * @param x the new column value
1941 * @param length the length of the stream
1942 * @exception SQLException if a database access error occurs
1943 */
1944 public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException {
1945 throw new UnsupportedOperationException("ResultSet.updateBinaryStream" + "(String, InputStream, int) unsupported");
1946 }
1947
1948 /***
1949 * Updates the designated column with a character stream value.
1950 * The updater methods are used to update column values in the
1951 * current row or the insert row. The updater methods do not
1952 * update the underlying database; instead the <code>updateRow</code> or
1953 * <code>insertRow</code> methods are called to update the database.
1954 *
1955 * @param columnName the name of the column
1956 * @param reader the <code>java.io.Reader</code> object containing
1957 * the new column value
1958 * @param length the length of the stream
1959 * @exception SQLException if a database access error occurs
1960 */
1961 public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException {
1962 throw new UnsupportedOperationException("ResultSet.updateCharacterStr" + "eam(String, Reader, int) unsupported");
1963 }
1964
1965 /***
1966 * Updates the designated column with an <code>Object</code> value.
1967 * The updater methods are used to update column values in the
1968 * current row or the insert row. The updater methods do not
1969 * update the underlying database; instead the <code>updateRow</code> or
1970 * <code>insertRow</code> methods are called to update the database.
1971 *
1972 * @param columnName the name of the column
1973 * @param x the new column value
1974 * @param scale for <code>java.sql.Types.DECIMAL</code>
1975 * or <code>java.sql.Types.NUMERIC</code> types,
1976 * this is the number of digits after the decimal point. For all other
1977 * types this value will be ignored.
1978 * @exception SQLException if a database access error occurs
1979 */
1980 public void updateObject(String columnName, Object x, int scale) throws SQLException {
1981 throw new UnsupportedOperationException("ResultSet.updateObject(String, Object, int) unsupported");
1982 }
1983
1984 /***
1985 * Updates the designated column with an <code>Object</code> value.
1986 * The updater methods are used to update column values in the
1987 * current row or the insert row. The updater methods do not
1988 * update the underlying database; instead the <code>updateRow</code> or
1989 * <code>insertRow</code> methods are called to update the database.
1990 *
1991 * @param columnName the name of the column
1992 * @param x the new column value
1993 * @exception SQLException if a database access error occurs
1994 */
1995 public void updateObject(String columnName, Object x) throws SQLException {
1996 throw new UnsupportedOperationException("ResultSet.updateObject(String, Object) unsupported");
1997 }
1998
1999 /***
2000 * Inserts the contents of the insert row into this
2001 * <code>ResultSet</code> object and into the database.
2002 * The cursor must be on the insert row when this method is called.
2003 *
2004 * @exception SQLException if a database access error occurs,
2005 * if this method is called when the cursor is not on the insert row,
2006 * or if not all of non-nullable columns in
2007 * the insert row have been given a value
2008 */
2009 public void insertRow() throws SQLException {
2010 throw new UnsupportedOperationException("ResultSet.insertRow() unsupported");
2011 }
2012
2013 /***
2014 * Updates the underlying database with the new contents of the
2015 * current row of this <code>ResultSet</code> object.
2016 * This method cannot be called when the cursor is on the insert row.
2017 *
2018 * @exception SQLException if a database access error occurs or
2019 * if this method is called when the cursor is on the insert row
2020 */
2021 public void updateRow() throws SQLException {
2022 throw new UnsupportedOperationException("ResultSet.updateRow() unsupported");
2023 }
2024
2025 /***
2026 * Deletes the current row from this <code>ResultSet</code> object
2027 * and from the underlying database. This method cannot be called when
2028 * the cursor is on the insert row.
2029 *
2030 * @exception SQLException if a database access error occurs
2031 * or if this method is called when the cursor is on the insert row
2032 */
2033 public void deleteRow() throws SQLException {
2034 throw new UnsupportedOperationException("ResultSet.deleteRow() unsupported");
2035 }
2036
2037 /***
2038 * Refreshes the current row with its most recent value in
2039 * the database. This method cannot be called when
2040 * the cursor is on the insert row.
2041 *
2042 * <P>The <code>refreshRow</code> method provides a way for an
2043 * application to
2044 * explicitly tell the JDBC driver to refetch a row(s) from the
2045 * database. An application may want to call <code>refreshRow</code> when
2046 * caching or prefetching is being done by the JDBC driver to
2047 * fetch the latest value of a row from the database. The JDBC driver
2048 * may actually refresh multiple rows at once if the fetch size is
2049 * greater than one.
2050 *
2051 * <P> All values are refetched subject to the transaction isolation
2052 * level and cursor sensitivity. If <code>refreshRow</code> is called after
2053 * calling an updater method, but before calling
2054 * the method <code>updateRow</code>, then the
2055 * updates made to the row are lost. Calling the method
2056 * <code>refreshRow</code> frequently will likely slow performance.
2057 *
2058 * @exception SQLException if a database access error
2059 * occurs or if this method is called when the cursor is on the insert row
2060 */
2061 public void refreshRow() throws SQLException {
2062 throw new UnsupportedOperationException("ResultSet.refreshRow() unsupported");
2063 }
2064
2065 /***
2066 * Cancels the updates made to the current row in this
2067 * <code>ResultSet</code> object.
2068 * This method may be called after calling an
2069 * updater method(s) and before calling
2070 * the method <code>updateRow</code> to roll back
2071 * the updates made to a row. If no updates have been made or
2072 * <code>updateRow</code> has already been called, this method has no
2073 * effect.
2074 *
2075 * @exception SQLException if a database access error
2076 * occurs or if this method is called when the cursor is
2077 * on the insert row
2078 */
2079 public void cancelRowUpdates() throws SQLException {
2080 throw new UnsupportedOperationException("ResultSet.cancelRowUpdates() unsupported");
2081 }
2082
2083 /***
2084 * Moves the cursor to the insert row. The current cursor position is
2085 * remembered while the cursor is positioned on the insert row.
2086 *
2087 * The insert row is a special row associated with an updatable
2088 * result set. It is essentially a buffer where a new row may
2089 * be constructed by calling the updater methods prior to
2090 * inserting the row into the result set.
2091 *
2092 * Only the updater, getter,
2093 * and <code>insertRow</code> methods may be
2094 * called when the cursor is on the insert row. All of the columns in
2095 * a result set must be given a value each time this method is
2096 * called before calling <code>insertRow</code>.
2097 * An updater method must be called before a
2098 * getter method can be called on a column value.
2099 *
2100 * @exception SQLException if a database access error occurs
2101 * or the result set is not updatable
2102 */
2103 public void moveToInsertRow() throws SQLException {
2104 throw new UnsupportedOperationException("ResultSet.moveToInsertRow() unsupported");
2105 }
2106
2107 /***
2108 * Moves the cursor to the remembered cursor position, usually the
2109 * current row. This method has no effect if the cursor is not on
2110 * the insert row.
2111 *
2112 * @exception SQLException if a database access error occurs
2113 * or the result set is not updatable
2114 */
2115 public void moveToCurrentRow() throws SQLException {
2116 throw new UnsupportedOperationException("ResultSet.moveToeCurrentRow() unsupported");
2117 }
2118
2119 /***
2120 * Retrieves the <code>Statement</code> object that produced this
2121 * <code>ResultSet</code> object.
2122 * If the result set was generated some other way, such as by a
2123 * <code>DatabaseMetaData</code> method, this method returns
2124 * <code>null</code>.
2125 *
2126 * @return the <code>Statment</code> object that produced
2127 * this <code>ResultSet</code> object or <code>null</code>
2128 * if the result set was produced some other way
2129 * @exception SQLException if a database access error occurs
2130 */
2131 public Statement getStatement() throws SQLException {
2132 throw new SQLException("Not implemented!");
2133 }
2134
2135 /***
2136 * Retrieves the value of the designated column in the current row
2137 * of this <code>ResultSet</code> object as an <code>Object</code>
2138 * in the Java programming language.
2139 * If the value is an SQL <code>NULL</code>,
2140 * the driver returns a Java <code>null</code>.
2141 * This method uses the given <code>Map</code> object
2142 * for the custom mapping of the
2143 * SQL structured or distinct type that is being retrieved.
2144 *
2145 * @param i the first column is 1, the second is 2, ...
2146 * @param map a <code>java.util.Map</code> object that contains the mapping
2147 * from SQL type names to classes in the Java programming language
2148 * @return an <code>Object</code> in the Java programming language
2149 * representing the SQL value
2150 * @exception SQLException if a database access error occurs
2151 */
2152 public Object getObject(int i, Map map) throws SQLException {
2153 throw new UnsupportedOperationException("ResultSet.getObject(int, Map) unsupported");
2154 }
2155
2156 /***
2157 * Retrieves the value of the designated column in the current row
2158 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2159 * in the Java programming language.
2160 *
2161 * @param i the first column is 1, the second is 2, ...
2162 * @return a <code>Ref</code> object representing an SQL <code>REF</code>
2163 * value
2164 * @exception SQLException if a database access error occurs
2165 */
2166 public Ref getRef(int i) throws SQLException {
2167 throw new UnsupportedOperationException("ResultSet.getRef(int) unsupported");
2168 }
2169
2170 /***
2171 * Retrieves the value of the designated column in the current row
2172 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2173 * in the Java programming language.
2174 *
2175 * @param i the first column is 1, the second is 2, ...
2176 * @return a <code>Blob</code> object representing the SQL
2177 * <code>BLOB</code> value in the specified column
2178 * @exception SQLException if a database access error occurs
2179 */
2180 public Blob getBlob(int i) throws SQLException {
2181 throw new UnsupportedOperationException("ResultSet.getBlob(int) unsupported");
2182 }
2183
2184 /***
2185 * Retrieves the value of the designated column in the current row
2186 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2187 * in the Java programming language.
2188 *
2189 * @param i the first column is 1, the second is 2, ...
2190 * @return a <code>Clob</code> object representing the SQL
2191 * <code>CLOB</code> value in the specified column
2192 * @exception SQLException if a database access error occurs
2193 */
2194 public Clob getClob(int i) throws SQLException {
2195 throw new UnsupportedOperationException("ResultSet.getClob(int) unsupported");
2196 }
2197
2198 /***
2199 * Retrieves the value of the designated column in the current row
2200 * of this <code>ResultSet</code> object as an <code>Array</code> object
2201 * in the Java programming language.
2202 *
2203 * @param i the first column is 1, the second is 2, ...
2204 * @return an <code>Array</code> object representing the SQL
2205 * <code>ARRAY</code> value in the specified column
2206 * @exception SQLException if a database access error occurs
2207 */
2208 public Array getArray(int i) throws SQLException {
2209 throw new UnsupportedOperationException("ResultSet.getArray(int) unsupported");
2210 }
2211
2212 /***
2213 * Retrieves the value of the designated column in the current row
2214 * of this <code>ResultSet</code> object as an <code>Object</code>
2215 * in the Java programming language.
2216 * If the value is an SQL <code>NULL</code>,
2217 * the driver returns a Java <code>null</code>.
2218 * This method uses the specified <code>Map</code> object for
2219 * custom mapping if appropriate.
2220 *
2221 * @param colName the name of the column from which to retrieve the value
2222 * @param map a <code>java.util.Map</code> object that contains the mapping
2223 * from SQL type names to classes in the Java programming language
2224 * @return an <code>Object</code> representing the SQL value in the
2225 * specified column
2226 * @exception SQLException if a database access error occurs
2227 */
2228 public Object getObject(String colName, Map map) throws SQLException {
2229 throw new UnsupportedOperationException("ResultSet.getObject(String, Map) unsupported");
2230 }
2231
2232 /***
2233 * Retrieves the value of the designated column in the current row
2234 * of this <code>ResultSet</code> object as a <code>Ref</code> object
2235 * in the Java programming language.
2236 *
2237 * @param colName the column name
2238 * @return a <code>Ref</code> object representing the SQL <code>REF</code>
2239 * value in the specified column
2240 * @exception SQLException if a database access error occurs
2241 */
2242 public Ref getRef(String colName) throws SQLException {
2243 throw new UnsupportedOperationException("ResultSet.getRef(String) unsupported");
2244 }
2245
2246 /***
2247 * Retrieves the value of the designated column in the current row
2248 * of this <code>ResultSet</code> object as a <code>Blob</code> object
2249 * in the Java programming language.
2250 *
2251 * @param colName the name of the column from which to retrieve the value
2252 * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
2253 * value in the specified column
2254 * @exception SQLException if a database access error occurs
2255 */
2256 public Blob getBlob(String colName) throws SQLException {
2257 throw new UnsupportedOperationException("ResultSet.getBlob(String) unsupported");
2258 }
2259
2260 /***
2261 * Retrieves the value of the designated column in the current row
2262 * of this <code>ResultSet</code> object as a <code>Clob</code> object
2263 * in the Java programming language.
2264 *
2265 * @param colName the name of the column from which to retrieve the value
2266 * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
2267 * value in the specified column
2268 * @exception SQLException if a database access error occurs
2269 */
2270 public Clob getClob(String colName) throws SQLException {
2271 throw new UnsupportedOperationException("ResultSet.getClob(String) unsupported");
2272 }
2273
2274 /***
2275 * Retrieves the value of the designated column in the current row
2276 * of this <code>ResultSet</code> object as an <code>Array</code> object
2277 * in the Java programming language.
2278 *
2279 * @param colName the name of the column from which to retrieve the value
2280 * @return an <code>Array</code> object representing the SQL
2281 * <code>ARRAY</code> value in the specified column
2282 * @exception SQLException if a database access error occurs
2283 */
2284 public Array getArray(String colName) throws SQLException {
2285 throw new UnsupportedOperationException("ResultSet.getArray(String) unsupported");
2286 }
2287
2288 /***
2289 * Retrieves the value of the designated column in the current row
2290 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code>
2291 * object in the Java programming language.
2292 * This method uses the given calendar to construct an appropriate
2293 * millisecond value for the date if the underlying database does not store
2294 * timezone information.
2295 *
2296 * @param columnIndex the first column is 1, the second is 2, ...
2297 * @param cal the <code>java.util.Calendar</code> object
2298 * to use in constructing the date
2299 * @return the column value as a <code>java.sql.Date</code> object;
2300 * if the value is SQL <code>NULL</code>,
2301 * the value returned is <code>null</code> in the Java programming language
2302 * @exception SQLException if a database access error occurs
2303 */
2304 public Date getDate(int columnIndex, Calendar cal) throws SQLException {
2305 throw new UnsupportedOperationException("ResultSet.getDate(int, Calendar) unsupported");
2306 }
2307
2308 /***
2309 * Retrieves the value of the designated column in the current row
2310 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code>
2311 * object in the Java programming language.
2312 * This method uses the given calendar to construct an appropriate
2313 * millisecond value for the date if the underlying database does not store
2314 * timezone information.
2315 *
2316 * @param columnName the SQL name of the column from which to retrieve the
2317 * value
2318 * @param cal the <code>java.util.Calendar</code> object
2319 * to use in constructing the date
2320 * @return the column value as a <code>java.sql.Date</code> object;
2321 * if the value is SQL <code>NULL</code>,
2322 * the value returned is <code>null</code> in the Java programming language
2323 * @exception SQLException if a database access error occurs
2324 */
2325 public Date getDate(String columnName, Calendar cal) throws SQLException {
2326 throw new UnsupportedOperationException("ResultSet.getDate(String, Calendar) unsupported");
2327 }
2328
2329 /***
2330 * Retrieves the value of the designated column in the current row
2331 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code>
2332 * object in the Java programming language.
2333 * This method uses the given calendar to construct an appropriate
2334 * millisecond value for the time if the underlying database does not store
2335 * timezone information.
2336 *
2337 * @param columnIndex the first column is 1, the second is 2, ...
2338 * @param cal the <code>java.util.Calendar</code> object
2339 * to use in constructing the time
2340 * @return the column value as a <code>java.sql.Time</code> object;
2341 * if the value is SQL <code>NULL</code>,
2342 * the value returned is <code>null</code> in the Java programming language
2343 * @exception SQLException if a database access error occurs
2344 */
2345 public Time getTime(int columnIndex, Calendar cal) throws SQLException {
2346 throw new UnsupportedOperationException("ResultSet.getTime(int, Calendar) unsupported");
2347 }
2348
2349 /***
2350 * Retrieves the value of the designated column in the current row
2351 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code>
2352 * object in the Java programming language.
2353 * This method uses the given calendar to construct an appropriate
2354 * millisecond value for the time if the underlying database does not store
2355 * timezone information.
2356 *
2357 * @param columnName the SQL name of the column
2358 * @param cal the <code>java.util.Calendar</code> object
2359 * to use in constructing the time
2360 * @return the column value as a <code>java.sql.Time</code> object;
2361 * if the value is SQL <code>NULL</code>,
2362 * the value returned is <code>null</code> in the Java programming language
2363 * @exception SQLException if a database access error occurs
2364 */
2365 public Time getTime(String columnName, Calendar cal) throws SQLException {
2366 throw new UnsupportedOperationException("ResultSet.getTime(String, Calendar) unsupported");
2367 }
2368
2369 /***
2370 * Retrieves the value of the designated column in the current row
2371 * of this <code>ResultSet</code> object as a
2372 * <code>java.sql.Timestamp</code> object in the Java programming language.
2373 * This method uses the given calendar to construct an appropriate
2374 * millisecond value for the timestamp if the underlying database does not
2375 * store timezone information.
2376 *
2377 * @param columnIndex the first column is 1, the second is 2, ...
2378 * @param cal the <code>java.util.Calendar</code> object
2379 * to use in constructing the timestamp
2380 * @return the column value as a <code>java.sql.Timestamp</code> object;
2381 * if the value is SQL <code>NULL</code>,
2382 * the value returned is <code>null</code> in the Java programming language
2383 * @exception SQLException if a database access error occurs
2384 */
2385 public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
2386 throw new UnsupportedOperationException("ResultSet.getTimestamp(int, Calendar) unsupported");
2387 }
2388
2389 /***
2390 * Retrieves the value of the designated column in the current row
2391 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code>
2392 * object in the Java programming language.
2393 * This method uses the given calendar to construct an appropriate
2394 * millisecond value for the time if the underlying database does not store
2395 * timezone information.
2396 *
2397 * @param columnName the SQL name of the column
2398 * @param cal the <code>java.util.Calendar</code> object
2399 * to use in constructing the time
2400 * @return the column value as a <code>java.sql.Time</code> object;
2401 * if the value is SQL <code>NULL</code>,
2402 * the value returned is <code>null</code> in the Java programming language
2403 * @exception SQLException if a database access error occurs
2404 */
2405 public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
2406 throw new UnsupportedOperationException("ResultSet.getTimestamp(String, Calendar) unsupported");
2407 }
2408
2409 //---------------------------------------------------------------------
2410 // I18n JDBC private helper methods
2411 //---------------------------------------------------------------------
2412
2413 /***
2414 * Perform pre-accessor method processing
2415 * @param columnIndex the first column is 1, the second is 2, ...
2416 * @exception SQLException if a database access error occurs
2417 */
2418 private void preAccessor(int columnIndex) throws SQLException {
2419 // set last read column index for wasNull()
2420 lastIndexRead = columnIndex;
2421 // implicitly close InputStream for get*Stream() between accessors
2422 if (is != null) {
2423 try {
2424 is.close();
2425 } catch (IOException e) {
2426 throw new SQLException("Could not close InputStream: " + e);
2427 }
2428 is = null;
2429 }
2430 }
2431
2432 /***
2433 * Perform pre-accessor method processing
2434 * @param columnName the SQL name of the column
2435 * @exception SQLException if a database access error occurs
2436 */
2437 private void preAccessor(String columnName) throws SQLException {
2438 // locate the index number and delegate to preAccessor(int)
2439 for (int i = 0; i < columnNames.length; i++) {
2440 if (columnName.equalsIgnoreCase(columnNames[i])) {
2441 preAccessor(i + 1);
2442 }
2443 }
2444 }
2445
2446 //---------------------------------------------------------------------
2447 // JDBC 3.0
2448 //---------------------------------------------------------------------
2449
2450 public URL getURL(int columnIndex) throws SQLException {
2451 throw new UnsupportedOperationException("ResultSet.getURL(int) unsupported");
2452 }
2453
2454 public URL getURL(String columnName) throws SQLException {
2455 throw new UnsupportedOperationException("ResultSet.getURL(String) unsupported");
2456 }
2457
2458 public void updateRef(int columnIndex, Ref x) throws SQLException {
2459 throw new UnsupportedOperationException("ResultSet.updateRef(int,java.sql.Ref) unsupported");
2460 }
2461
2462 public void updateRef(String columnName, Ref x) throws SQLException {
2463 throw new UnsupportedOperationException("ResultSet.updateRef(String,java.sql.Ref) unsupported");
2464 }
2465
2466 public void updateBlob(int columnIndex, Blob x) throws SQLException {
2467 throw new UnsupportedOperationException("ResultSet.updateBlob(int,java.sql.Blob) unsupported");
2468 }
2469
2470 public void updateBlob(String columnName, Blob x) throws SQLException {
2471 throw new UnsupportedOperationException("ResultSet.updateBlob(String,java.sql.Blob) unsupported");
2472 }
2473
2474 public void updateClob(int columnIndex, Clob x) throws SQLException {
2475 throw new UnsupportedOperationException("ResultSet.updateClob(int,java.sql.Clob) unsupported");
2476 }
2477
2478 public void updateClob(String columnName, Clob x) throws SQLException {
2479 throw new UnsupportedOperationException("ResultSet.updateClob(String,java.sql.Clob) unsupported");
2480 }
2481
2482 public void updateArray(int columnIndex, Array x) throws SQLException {
2483 throw new UnsupportedOperationException("ResultSet.updateArray(int,java.sql.Array) unsupported");
2484 }
2485
2486 public void updateArray(String columnName, Array x) throws SQLException {
2487 throw new UnsupportedOperationException("ResultSet.updateArray(String,java.sql.Array) unsupported");
2488 }
2489
2490 // private String formatString(String str) throws SQLException {
2491 // String retValue = str;
2492 // try {
2493 // //replace spec. characters
2494 // retValue = I18nSqlParser.replaceAll(retValue,
2495 // ( (I18nConnection) statement.getConnection()).
2496 // getLineBreakEscape(), "\n");
2497 // retValue = I18nSqlParser.replaceAll(retValue,
2498 // ( (I18nConnection) statement.getConnection()).
2499 // getDoubleQuotesEscape(), "\"");
2500 // }catch(Exception e) {
2501 // throw new SQLException("Error while reformat string ! : "+str);
2502 // }
2503 // return retValue;
2504 // }
2505
2506 }
This page was automatically generated by Maven