Source code: com/rohanclan/ashpool/core/AResultSet.java
1 /*
2 * Ashpool - XML Database
3 * Copyright (C) 2003 Rob Rohan
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 675 Mass Ave, Cambridge, MA 02139, USA.
17 *
18 * ResultSet.java
19 *
20 * Created on January 30, 2003, 7:20 PM
21 */
22
23 package com.rohanclan.ashpool.core;
24
25 import java.sql.*;
26 import java.math.*;
27 import java.util.*;
28 import com.rohanclan.ashpool.jdbc.*;
29
30 /**
31 *
32 * @author rob
33 */
34 public class AResultSet implements java.sql.ResultSet {
35
36 private int currentrow = -1;
37 private Vector resultTable;
38 private AResultSetMetaData rsmetadata;
39
40 /** Creates a new instance of ResultSet */
41 public AResultSet() {
42 resultTable = new Vector();
43 }
44
45 /** add a column (with a name and type) to the result set
46 */
47 public void addColumn(String name, Vector data, int type){
48 resultTable.add(new ResultColumn());
49 ((ResultColumn)resultTable.lastElement()).columnName = name;
50 ((ResultColumn)resultTable.lastElement()).type = type;
51 ((ResultColumn)resultTable.lastElement()).columnData = data;
52 }
53
54 /** resets this result set object so it can be reused */
55 public void reset(){
56 //clear all the columns
57 resultTable.removeAllElements();
58 //park the cursor
59 currentrow=-1;
60 }
61
62 public void addResultColumn(ResultColumn column){
63 resultTable.add(column);
64 }
65
66 /** gets a handle to the result table */
67 public Vector getResultTable(){
68 return resultTable;
69 }
70
71 /** add a row to the result set
72 */
73 public void addRow(Vector data){
74 //has to have the same number of "columns"
75 if(data.size() != resultTable.size()) return;
76
77 //TODO: each column needs to be the same type
78
79 //add the datas column value to the tables column value
80 for(int tcolumn=0; tcolumn<resultTable.size(); tcolumn++){
81 ((ResultColumn)resultTable.get(tcolumn)).columnData.add(data.get(tcolumn));
82 }
83 }
84
85 /** add a field to the end of a column */
86 public void addField(int column, String data){
87 ((ResultColumn)resultTable.get(column)).columnData.add(data);
88 }
89
90 /** make a quick result set. Used mostly to pass messages that need
91 * to be in Restulset format. This should only be called once! should
92 * not be used when build a result set that contains more information then
93 * this one call.
94 */
95 public void setQuickResultSet(String colname, String data){
96 Vector tempV = new Vector();
97 tempV.add(data);
98 addColumn(colname, tempV, java.sql.Types.VARCHAR);
99 }
100
101 /** Moves the cursor to the given row number in
102 * this <code>ResultSet</code> object.
103 *
104 * <p>If the row number is positive, the cursor moves to
105 * the given row number with respect to the
106 * beginning of the result set. The first row is row 1, the second
107 * is row 2, and so on.
108 *
109 * <p>If the given row number is negative, the cursor moves to
110 * an absolute row position with respect to
111 * the end of the result set. For example, calling the method
112 * <code>absolute(-1)</code> positions the
113 * cursor on the last row; calling the method <code>absolute(-2)</code>
114 * moves the cursor to the next-to-last row, and so on.
115 *
116 * <p>An attempt to position the cursor beyond the first/last row in
117 * the result set leaves the cursor before the first row or after
118 * the last row.
119 *
120 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
121 * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
122 * is the same as calling <code>last()</code>.
123 *
124 * @param row the number of the row to which the cursor should move.
125 * A positive number indicates the row number counting from the
126 * beginning of the result set; a negative number indicates the
127 * row number counting from the end of the result set
128 * @return <code>true</code> if the cursor is on the result set;
129 * <code>false</code> otherwise
130 * @exception SQLException if a database access error
131 * occurs, or the result set type is <code>TYPE_FORWARD_ONLY</code>
132 * @since 1.2
133 *
134 */
135 public boolean absolute(int row) throws SQLException {
136 return true;
137 }
138
139 /** Moves the cursor to the end of
140 * this <code>ResultSet</code> object, just after the
141 * last row. This method has no effect if the result set contains no rows.
142 * @exception SQLException if a database access error
143 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
144 * @since 1.2
145 *
146 */
147 public void afterLast() throws SQLException {;}
148
149 /** Moves the cursor to the front of
150 * this <code>ResultSet</code> object, just before the
151 * first row. This method has no effect if the result set contains no rows.
152 *
153 * @exception SQLException if a database access error
154 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
155 * @since 1.2
156 *
157 */
158 public void beforeFirst() throws SQLException {;}
159
160 /** Cancels the updates made to the current row in this
161 * <code>ResultSet</code> object.
162 * This method may be called after calling an
163 * updater method(s) and before calling
164 * the method <code>updateRow</code> to roll back
165 * the updates made to a row. If no updates have been made or
166 * <code>updateRow</code> has already been called, this method has no
167 * effect.
168 *
169 * @exception SQLException if a database access error
170 * occurs or if this method is called when the cursor is
171 * on the insert row
172 * @since 1.2
173 *
174 */
175 public void cancelRowUpdates() throws SQLException {;}
176
177 /** Clears all warnings reported on this <code>ResultSet</code> object.
178 * After this method is called, the method <code>getWarnings</code>
179 * returns <code>null</code> until a new warning is
180 * reported for this <code>ResultSet</code> object.
181 *
182 * @exception SQLException if a database access error occurs
183 *
184 */
185 public void clearWarnings() throws SQLException {;}
186
187 /** Releases this <code>ResultSet</code> object's database and
188 * JDBC resources immediately instead of waiting for
189 * this to happen when it is automatically closed.
190 *
191 * <P><B>Note:</B> A <code>ResultSet</code> object
192 * is automatically closed by the
193 * <code>Statement</code> object that generated it when
194 * that <code>Statement</code> object is closed,
195 * re-executed, or is used to retrieve the next result from a
196 * sequence of multiple results. A <code>ResultSet</code> object
197 * is also automatically closed when it is garbage collected.
198 *
199 * @exception SQLException if a database access error occurs
200 *
201 */
202 public void close() throws SQLException {;}
203
204 /** Deletes the current row from this <code>ResultSet</code> object
205 * and from the underlying database. This method cannot be called when
206 * the cursor is on the insert row.
207 *
208 * @exception SQLException if a database access error occurs
209 * or if this method is called when the cursor is on the insert row
210 * @since 1.2
211 *
212 */
213 public void deleteRow() throws SQLException {;}
214
215 /** Maps the given <code>ResultSet</code> column name to its
216 * <code>ResultSet</code> column index.
217 *
218 * @param columnName the name of the column
219 * @return the column index of the given column name
220 * @exception SQLException if the <code>ResultSet</code> object
221 * does not contain <code>columnName</code> or a database access error occurs
222 *
223 */
224 public int findColumn(String columnName) throws SQLException {
225 for(int x=0; x<resultTable.size(); x++){
226 if(
227 ((ResultColumn)resultTable.get(x)).columnName.toLowerCase().equals(columnName.toLowerCase())
228 ){
229 return x;
230 }
231 }
232 throw new SQLException("AResult::getString(String): column or selection past result set or unknown name: " + columnName);
233 }
234
235 /** check to see if the column is in the result set */
236 public boolean columnExists(String columnName){
237 try{
238 if(findColumn(columnName) >= 0){
239 return true;
240 }
241 }catch(Exception e){
242 return false;
243 }
244 return false;
245 }
246
247 /** Moves the cursor to the first row in
248 * this <code>ResultSet</code> object.
249 *
250 * @return <code>true</code> if the cursor is on a valid row;
251 * <code>false</code> if there are no rows in the result set
252 * @exception SQLException if a database access error
253 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
254 * @since 1.2
255 *
256 */
257 public boolean first() throws SQLException {
258 return false;
259 }
260
261 /** Retrieves the value of the designated column in the current row
262 * of this <code>ResultSet</code> object as an <code>Array</code> object
263 * in the Java programming language.
264 *
265 * @param i the first column is 1, the second is 2, ...
266 * @return an <code>Array</code> object representing the SQL
267 * <code>ARRAY</code> value in the specified column
268 * @exception SQLException if a database access error occurs
269 * @since 1.2
270 *
271 */
272 public Array getArray(int i) throws SQLException {
273 return null;
274 }
275
276 /** Retrieves the value of the designated column in the current row
277 * of this <code>ResultSet</code> object as an <code>Array</code> object
278 * in the Java programming language.
279 *
280 * @param colName the name of the column from which to retrieve the value
281 * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> value in
282 * the specified column
283 * @exception SQLException if a database access error occurs
284 * @since 1.2
285 *
286 */
287 public Array getArray(String colName) throws SQLException {
288 return null;
289 }
290
291 /** Retrieves the value of the designated column in the current row
292 * of this <code>ResultSet</code> object as a stream of
293 * ASCII characters. The value can then be read in chunks from the
294 * stream. This method is particularly
295 * suitable for retrieving large <code>LONGVARCHAR</code> values.
296 * The JDBC driver will
297 * do any necessary conversion from the database format into ASCII.
298 *
299 * <P><B>Note:</B> All the data in the returned stream must be
300 * read prior to getting the value of any other column. The next
301 * call to a getter method implicitly closes the stream. Also, a
302 * stream may return <code>0</code> when the method <code>available</code>
303 * is called whether there is data available or not.
304 *
305 * @param columnName the SQL name of the column
306 * @return a Java input stream that delivers the database column value
307 * as a stream of one-byte ASCII characters.
308 * If the value is SQL <code>NULL</code>,
309 * the value returned is <code>null</code>.
310 * @exception SQLException if a database access error occurs
311 *
312 */
313 public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
314 return null;
315 }
316
317 /** Retrieves the value of the designated column in the current row
318 * of this <code>ResultSet</code> object as
319 * a stream of ASCII characters. The value can then be read in chunks from the
320 * stream. This method is particularly
321 * suitable for retrieving large <char>LONGVARCHAR</char> values.
322 * The JDBC driver will
323 * do any necessary conversion from the database format into ASCII.
324 *
325 * <P><B>Note:</B> All the data in the returned stream must be
326 * read prior to getting the value of any other column. The next
327 * call to a getter method implicitly closes the stream. Also, a
328 * stream may return <code>0</code> when the method
329 * <code>InputStream.available</code>
330 * is called whether there is data available or not.
331 *
332 * @param columnIndex the first column is 1, the second is 2, ...
333 * @return a Java input stream that delivers the database column value
334 * as a stream of one-byte ASCII characters;
335 * if the value is SQL <code>NULL</code>, the
336 * value returned is <code>null</code>
337 * @exception SQLException if a database access error occurs
338 *
339 */
340 public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
341 return null;
342 }
343
344 /** Retrieves the value of the designated column in the current row
345 * of this <code>ResultSet</code> object as a
346 * <code>java.math.BigDecimal</code> with full precision.
347 *
348 * @param columnName the column name
349 * @return the column value (full precision);
350 * if the value is SQL <code>NULL</code>, the value returned is
351 * <code>null</code> in the Java programming language.
352 * @exception SQLException if a database access error occurs
353 * @since 1.2
354 *
355 *
356 */
357 public BigDecimal getBigDecimal(String columnName) throws SQLException {
358 return null;
359 }
360
361 /** Retrieves the value of the designated column in the current row
362 * of this <code>ResultSet</code> object as a
363 * <code>java.math.BigDecimal</code> with full precision.
364 *
365 * @param columnIndex the first column is 1, the second is 2, ...
366 * @return the column value (full precision);
367 * if the value is SQL <code>NULL</code>, the value returned is
368 * <code>null</code> in the Java programming language.
369 * @exception SQLException if a database access error occurs
370 * @since 1.2
371 *
372 */
373 public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
374 return null;
375 }
376
377 /** Retrieves the value of the designated column in the current row
378 * of this <code>ResultSet</code> object as
379 * a <code>java.sql.BigDecimal</code> in the Java programming language.
380 *
381 * @param columnIndex the first column is 1, the second is 2, ...
382 * @param scale the number of digits to the right of the decimal point
383 * @return the column value; if the value is SQL <code>NULL</code>, the
384 * value returned is <code>null</code>
385 * @exception SQLException if a database access error occurs
386 * @deprecated
387 *
388 */
389 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
390 return null;
391 }
392
393 /** Retrieves the value of the designated column in the current row
394 * of this <code>ResultSet</code> object as
395 * a <code>java.math.BigDecimal</code> in the Java programming language.
396 *
397 * @param columnName the SQL name of the column
398 * @param scale the number of digits to the right of the decimal point
399 * @return the column value; if the value is SQL <code>NULL</code>, the
400 * value returned is <code>null</code>
401 * @exception SQLException if a database access error occurs
402 * @deprecated
403 *
404 */
405 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
406 return null;
407 }
408
409 /** Retrieves the value of the designated column in the current row
410 * of this <code>ResultSet</code> object as a binary stream of
411 * uninterpreted bytes. The value can then be read in chunks from the
412 * stream. This method is particularly
413 * suitable for retrieving large <code>LONGVARBINARY</code> values.
414 *
415 * <P><B>Note:</B> All the data in the returned stream must be
416 * read prior to getting the value of any other column. The next
417 * call to a getter method implicitly closes the stream. Also, a
418 * stream may return <code>0</code> when the method
419 * <code>InputStream.available</code>
420 * is called whether there is data available or not.
421 *
422 * @param columnIndex the first column is 1, the second is 2, ...
423 * @return a Java input stream that delivers the database column value
424 * as a stream of uninterpreted bytes;
425 * if the value is SQL <code>NULL</code>, the value returned is
426 * <code>null</code>
427 * @exception SQLException if a database access error occurs
428 *
429 */
430 public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
431 return null;
432 }
433
434 /** Retrieves the value of the designated column in the current row
435 * of this <code>ResultSet</code> object as a stream of uninterpreted
436 * <code>byte</code>s.
437 * The value can then be read in chunks from the
438 * stream. This method is particularly
439 * suitable for retrieving large <code>LONGVARBINARY</code>
440 * values.
441 *
442 * <P><B>Note:</B> All the data in the returned stream must be
443 * read prior to getting the value of any other column. The next
444 * call to a getter method implicitly closes the stream. Also, a
445 * stream may return <code>0</code> when the method <code>available</code>
446 * is called whether there is data available or not.
447 *
448 * @param columnName the SQL name of the column
449 * @return a Java input stream that delivers the database column value
450 * as a stream of uninterpreted bytes;
451 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
452 * @exception SQLException if a database access error occurs
453 *
454 */
455 public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
456 return null;
457 }
458
459 /** Retrieves the value of the designated column in the current row
460 * of this <code>ResultSet</code> object as a <code>Blob</code> object
461 * in the Java programming language.
462 *
463 * @param i the first column is 1, the second is 2, ...
464 * @return a <code>Blob</code> object representing the SQL
465 * <code>BLOB</code> value in the specified column
466 * @exception SQLException if a database access error occurs
467 * @since 1.2
468 *
469 */
470 public Blob getBlob(int i) throws SQLException {
471 return null;
472 }
473
474 /** Retrieves the value of the designated column in the current row
475 * of this <code>ResultSet</code> object as a <code>Blob</code> object
476 * in the Java programming language.
477 *
478 * @param colName the name of the column from which to retrieve the value
479 * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
480 * value in the specified column
481 * @exception SQLException if a database access error occurs
482 * @since 1.2
483 *
484 */
485 public Blob getBlob(String colName) throws SQLException {
486 return null;
487 }
488
489 /** Retrieves the value of the designated column in the current row
490 * of this <code>ResultSet</code> object as
491 * a <code>boolean</code> in the Java programming language.
492 *
493 * @param columnIndex the first column is 1, the second is 2, ...
494 * @return the column value; if the value is SQL <code>NULL</code>, the
495 * value returned is <code>false</code>
496 * @exception SQLException if a database access error occurs
497 *
498 */
499 public boolean getBoolean(int columnIndex) throws SQLException {
500 return false;
501 }
502
503 /** Retrieves the value of the designated column in the current row
504 * of this <code>ResultSet</code> object as
505 * a <code>boolean</code> in the Java programming language.
506 *
507 * @param columnName the SQL name of the column
508 * @return the column value; if the value is SQL <code>NULL</code>, the
509 * value returned is <code>false</code>
510 * @exception SQLException if a database access error occurs
511 *
512 */
513 public boolean getBoolean(String columnName) throws SQLException {
514 return false;
515 }
516
517 /** Retrieves the value of the designated column in the current row
518 * of this <code>ResultSet</code> object as
519 * a <code>byte</code> in the Java programming language.
520 *
521 * @param columnIndex the first column is 1, the second is 2, ...
522 * @return the column value; if the value is SQL <code>NULL</code>, the
523 * value returned is <code>0</code>
524 * @exception SQLException if a database access error occurs
525 *
526 */
527 public byte getByte(int columnIndex) throws SQLException {
528 return 0;
529 }
530
531 /** Retrieves the value of the designated column in the current row
532 * of this <code>ResultSet</code> object as
533 * a <code>byte</code> in the Java programming language.
534 *
535 * @param columnName the SQL name of the column
536 * @return the column value; if the value is SQL <code>NULL</code>, the
537 * value returned is <code>0</code>
538 * @exception SQLException if a database access error occurs
539 *
540 */
541 public byte getByte(String columnName) throws SQLException {
542 return 0;
543 }
544
545 /** Retrieves the value of the designated column in the current row
546 * of this <code>ResultSet</code> object as
547 * a <code>byte</code> array in the Java programming language.
548 * The bytes represent the raw values returned by the driver.
549 *
550 * @param columnIndex the first column is 1, the second is 2, ...
551 * @return the column value; if the value is SQL <code>NULL</code>, the
552 * value returned is <code>null</code>
553 * @exception SQLException if a database access error occurs
554 *
555 */
556 public byte[] getBytes(int columnIndex) throws SQLException {
557 return null;
558 }
559
560 /** Retrieves the value of the designated column in the current row
561 * of this <code>ResultSet</code> object as
562 * a <code>byte</code> array in the Java programming language.
563 * The bytes represent the raw values returned by the driver.
564 *
565 * @param columnName the SQL name of the column
566 * @return the column value; if the value is SQL <code>NULL</code>, the
567 * value returned is <code>null</code>
568 * @exception SQLException if a database access error occurs
569 *
570 */
571 public byte[] getBytes(String columnName) throws SQLException {
572 return null;
573 }
574
575 /** Retrieves the value of the designated column in the current row
576 * of this <code>ResultSet</code> object as a
577 * <code>java.io.Reader</code> object.
578 * @return a <code>java.io.Reader</code> object that contains the column
579 * value; if the value is SQL <code>NULL</code>, the value returned is
580 * <code>null</code> in the Java programming language.
581 * @param columnIndex the first column is 1, the second is 2, ...
582 * @exception SQLException if a database access error occurs
583 * @since 1.2
584 *
585 */
586 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException {
587 return null;
588 }
589
590 /** Retrieves the value of the designated column in the current row
591 * of this <code>ResultSet</code> object as a
592 * <code>java.io.Reader</code> object.
593 *
594 * @param columnName the name of the column
595 * @return a <code>java.io.Reader</code> object that contains the column
596 * value; if the value is SQL <code>NULL</code>, the value returned is
597 * <code>null</code> in the Java programming language
598 * @exception SQLException if a database access error occurs
599 * @since 1.2
600 *
601 */
602 public java.io.Reader getCharacterStream(String columnName) throws SQLException {
603 return null;
604 }
605
606 /** Retrieves the value of the designated column in the current row
607 * of this <code>ResultSet</code> object as a <code>Clob</code> object
608 * in the Java programming language.
609 *
610 * @param i the first column is 1, the second is 2, ...
611 * @return a <code>Clob</code> object representing the SQL
612 * <code>CLOB</code> value in the specified column
613 * @exception SQLException if a database access error occurs
614 * @since 1.2
615 *
616 */
617 public Clob getClob(int i) throws SQLException {
618 return null;
619 }
620
621 /** Retrieves the value of the designated column in the current row
622 * of this <code>ResultSet</code> object as a <code>Clob</code> object
623 * in the Java programming language.
624 *
625 * @param colName the name of the column from which to retrieve the value
626 * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
627 * value in the specified column
628 * @exception SQLException if a database access error occurs
629 * @since 1.2
630 *
631 */
632 public Clob getClob(String colName) throws SQLException {
633 return null;
634 }
635
636 /** Retrieves the concurrency mode of this <code>ResultSet</code> object.
637 * The concurrency used is determined by the
638 * <code>Statement</code> object that created the result set.
639 *
640 * @return the concurrency type, either
641 * <code>ResultSet.CONCUR_READ_ONLY</code>
642 * or <code>ResultSet.CONCUR_UPDATABLE</code>
643 * @exception SQLException if a database access error occurs
644 * @since 1.2
645 *
646 */
647 public int getConcurrency() throws SQLException {
648 return 0;
649 }
650
651 /** Retrieves the name of the SQL cursor used by this <code>ResultSet</code>
652 * object.
653 *
654 * <P>In SQL, a result table is retrieved through a cursor that is
655 * named. The current row of a result set can be updated or deleted
656 * using a positioned update/delete statement that references the
657 * cursor name. To insure that the cursor has the proper isolation
658 * level to support update, the cursor's <code>SELECT</code> statement
659 * should be of the form <code>SELECT FOR UPDATE</code>. If
660 * <code>FOR UPDATE</code> is omitted, the positioned updates may fail.
661 *
662 * <P>The JDBC API supports this SQL feature by providing the name of the
663 * SQL cursor used by a <code>ResultSet</code> object.
664 * The current row of a <code>ResultSet</code> object
665 * is also the current row of this SQL cursor.
666 *
667 * <P><B>Note:</B> If positioned update is not supported, a
668 * <code>SQLException</code> is thrown.
669 *
670 * @return the SQL name for this <code>ResultSet</code> object's cursor
671 * @exception SQLException if a database access error occurs
672 *
673 */
674 public String getCursorName() throws SQLException {
675 return "";
676 }
677
678 /** Retrieves the value of the designated column in the current row
679 * of this <code>ResultSet</code> object as
680 * a <code>java.sql.Date</code> object in the Java programming language.
681 *
682 * @param columnIndex the first column is 1, the second is 2, ...
683 * @return the column value; if the value is SQL <code>NULL</code>, the
684 * value returned is <code>null</code>
685 * @exception SQLException if a database access error occurs
686 *
687 */
688 public java.sql.Date getDate(int columnIndex) throws SQLException {
689 return null;
690 }
691
692 /** Retrieves the value of the designated column in the current row
693 * of this <code>ResultSet</code> object as
694 * a <code>java.sql.Date</code> object in the Java programming language.
695 *
696 * @param columnName the SQL name of the column
697 * @return the column value; if the value is SQL <code>NULL</code>, the
698 * value returned is <code>null</code>
699 * @exception SQLException if a database access error occurs
700 *
701 */
702 public java.sql.Date getDate(String columnName) throws SQLException {
703 return null;
704 }
705
706 /** Retrieves the value of the designated column in the current row
707 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
708 * in the Java programming language.
709 * This method uses the given calendar to construct an appropriate millisecond
710 * value for the date if the underlying database does not store
711 * timezone information.
712 *
713 * @param columnIndex the first column is 1, the second is 2, ...
714 * @param cal the <code>java.util.Calendar</code> object
715 * to use in constructing the date
716 * @return the column value as a <code>java.sql.Date</code> object;
717 * if the value is SQL <code>NULL</code>,
718 * the value returned is <code>null</code> in the Java programming language
719 * @exception SQLException if a database access error occurs
720 * @since 1.2
721 *
722 */
723 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
724 return null;
725 }
726
727 /** Retrieves the value of the designated column in the current row
728 * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
729 * in the Java programming language.
730 * This method uses the given calendar to construct an appropriate millisecond
731 * value for the date if the underlying database does not store
732 * timezone information.
733 *
734 * @param columnName the SQL name of the column from which to retrieve the value
735 * @param cal the <code>java.util.Calendar</code> object
736 * to use in constructing the date
737 * @return the column value as a <code>java.sql.Date</code> object;
738 * if the value is SQL <code>NULL</code>,
739 * the value returned is <code>null</code> in the Java programming language
740 * @exception SQLException if a database access error occurs
741 * @since 1.2
742 *
743 */
744 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
745 return null;
746 }
747
748 /** Retrieves the value of the designated column in the current row
749 * of this <code>ResultSet</code> object as
750 * a <code>double</code> in the Java programming language.
751 *
752 * @param columnIndex the first column is 1, the second is 2, ...
753 * @return the column value; if the value is SQL <code>NULL</code>, the
754 * value returned is <code>0</code>
755 * @exception SQLException if a database access error occurs
756 *
757 */
758 public double getDouble(int columnIndex) throws SQLException {
759 return 0;
760 }
761
762 /** Retrieves the value of the designated column in the current row
763 * of this <code>ResultSet</code> object as
764 * a <code>double</code> in the Java programming language.
765 *
766 * @param columnName the SQL name of the column
767 * @return the column value; if the value is SQL <code>NULL</code>, the
768 * value returned is <code>0</code>
769 * @exception SQLException if a database access error occurs
770 *
771 */
772 public double getDouble(String columnName) throws SQLException {
773 return 0;
774 }
775
776 /** Retrieves the fetch direction for this
777 * <code>ResultSet</code> object.
778 *
779 * @return the current fetch direction for this <code>ResultSet</code> object
780 * @exception SQLException if a database access error occurs
781 * @since 1.2
782 * @see #setFetchDirection
783 *
784 */
785 public int getFetchDirection() throws SQLException {
786 return 0;
787 }
788
789 /** Retrieves the fetch size for this
790 * <code>ResultSet</code> object.
791 *
792 * @return the current fetch size for this <code>ResultSet</code> object
793 * @exception SQLException if a database access error occurs
794 * @since 1.2
795 * @see #setFetchSize
796 *
797 */
798 public int getFetchSize() throws SQLException {
799 return 0;
800 }
801
802 /** Retrieves the value of the designated column in the current row
803 * of this <code>ResultSet</code> object as
804 * a <code>float</code> in the Java programming language.
805 *
806 * @param columnIndex the first column is 1, the second is 2, ...
807 * @return the column value; if the value is SQL <code>NULL</code>, the
808 * value returned is <code>0</code>
809 * @exception SQLException if a database access error occurs
810 *
811 */
812 public float getFloat(int columnIndex) throws SQLException {
813 return 0;
814 }
815
816 /** Retrieves the value of the designated column in the current row
817 * of this <code>ResultSet</code> object as
818 * a <code>float</code> in the Java programming language.
819 *
820 * @param columnName the SQL name of the column
821 * @return the column value; if the value is SQL <code>NULL</code>, the
822 * value returned is <code>0</code>
823 * @exception SQLException if a database access error occurs
824 *
825 */
826 public float getFloat(String columnName) throws SQLException {
827 return 0;
828 }
829
830 /** Retrieves the value of the designated column in the current row
831 * of this <code>ResultSet</code> object as
832 * an <code>int</code> in the Java programming language.
833 *
834 * @param columnName the SQL name of the column
835 * @return the column value; if the value is SQL <code>NULL</code>, the
836 * value returned is <code>0</code>
837 * @exception SQLException if a database access error occurs
838 *
839 */
840 public int getInt(String columnName) throws SQLException {
841 return 0;
842 }
843
844 /** Retrieves the value of the designated column in the current row
845 * of this <code>ResultSet</code> object as
846 * an <code>int</code> in the Java programming language.
847 *
848 * @param columnIndex the first column is 1, the second is 2, ...
849 * @return the column value; if the value is SQL <code>NULL</code>, the
850 * value returned is <code>0</code>
851 * @exception SQLException if a database access error occurs
852 *
853 */
854 public int getInt(int columnIndex) throws SQLException {
855 return 0;
856 }
857
858 /** Retrieves the value of the designated column in the current row
859 * of this <code>ResultSet</code> object as
860 * a <code>long</code> in the Java programming language.
861 *
862 * @param columnIndex the first column is 1, the second is 2, ...
863 * @return the column value; if the value is SQL <code>NULL</code>, the
864 * value returned is <code>0</code>
865 * @exception SQLException if a database access error occurs
866 *
867 */
868 public long getLong(int columnIndex) throws SQLException {
869 long value = Long.parseLong(((ResultColumn)resultTable.get(columnIndex - 1)).columnData.get(currentrow).toString());
870 return value;
871 }
872
873 /** Retrieves the value of the designated column in the current row
874 * of this <code>ResultSet</code> object as
875 * a <code>long</code> in the Java programming language.
876 *
877 * @param columnName the SQL name of the column
878 * @return the column value; if the value is SQL <code>NULL</code>, the
879 * value returned is <code>0</code>
880 * @exception SQLException if a database access error occurs
881 *
882 */
883 public long getLong(String columnName) throws SQLException {
884 return getLong(findColumn(columnName));
885 }
886
887 /** Retrieves the number, types and properties of
888 * this <code>ResultSet</code> object's columns.
889 *
890 * @return the description of this <code>ResultSet</code> object's columns
891 * @exception SQLException if a database access error occurs
892 *
893 */
894 public ResultSetMetaData getMetaData() throws SQLException {
895 return new AResultSetMetaData(this);
896 }
897
898 /** <p>Gets the value of the designated column in the current row
899 * of this <code>ResultSet</code> object as
900 * an <code>Object</code> in the Java programming language.
901 *
902 * <p>This method will return the value of the given column as a
903 * Java object. The type of the Java object will be the default
904 * Java object type corresponding to the column's SQL type,
905 * following the mapping for built-in types specified in the JDBC
906 * specification. If the value is an SQL <code>NULL</code>,
907 * the driver returns a Java <code>null</code>.
908 *
909 * <p>This method may also be used to read datatabase-specific
910 * abstract data types.
911 *
912 * In the JDBC 2.0 API, the behavior of method
913 * <code>getObject</code> is extended to materialize
914 * data of SQL user-defined types. When a column contains
915 * a structured or distinct value, the behavior of this method is as
916 * if it were a call to: <code>getObject(columnIndex,
917 * this.getStatement().getConnection().getTypeMap())</code>.
918 *
919 * @param columnIndex the first column is 1, the second is 2, ...
920 * @return a <code>java.lang.Object</code> holding the column value
921 * @exception SQLException if a database access error occurs
922 *
923 */
924 public Object getObject(int columnIndex) throws SQLException {
925 return null;
926 }
927
928 /** <p>Gets the value of the designated column in the current row
929 * of this <code>ResultSet</code> object as
930 * an <code>Object</code> in the Java programming language.
931 *
932 * <p>This method will return the value of the given column as a
933 * Java object. The type of the Java object will be the default
934 * Java object type corresponding to the column's SQL type,
935 * following the mapping for built-in types specified in the JDBC
936 * specification. If the value is an SQL <code>NULL</code>,
937 * the driver returns a Java <code>null</code>.
938 * <P>
939 * This method may also be used to read datatabase-specific
940 * abstract data types.
941 * <P>
942 * In the JDBC 2.0 API, the behavior of the method
943 * <code>getObject</code> is extended to materialize
944 * data of SQL user-defined types. When a column contains
945 * a structured or distinct value, the behavior of this method is as
946 * if it were a call to: <code>getObject(columnIndex,
947 * this.getStatement().getConnection().getTypeMap())</code>.
948 *
949 * @param columnName the SQL name of the column
950 * @return a <code>java.lang.Object</code> holding the column value
951 * @exception SQLException if a database access error occurs
952 *
953 */
954 public Object getObject(String columnName) throws SQLException {
955 return null;
956 }
957
958 /** Retrieves the value of the designated column in the current row
959 * of this <code>ResultSet</code> object as an <code>Object</code>
960 * in the Java programming language.
961 * If the value is an SQL <code>NULL</code>,
962 * the driver returns a Java <code>null</code>.
963 * This method uses the given <code>Map</code> object
964 * for the custom mapping of the
965 * SQL structured or distinct type that is being retrieved.
966 *
967 * @param i the first column is 1, the second is 2, ...
968 * @param map a <code>java.util.Map</code> object that contains the mapping
969 * from SQL type names to classes in the Java programming language
970 * @return an <code>Object</code> in the Java programming language
971 * representing the SQL value
972 * @exception SQLException if a database access error occurs
973 * @since 1.2
974 *
975 */
976 public Object getObject(int i, java.util.Map map) throws SQLException {
977 return null;
978 }
979
980 /** Retrieves the value of the designated column in the current row
981 * of this <code>ResultSet</code> object as an <code>Object</code>
982 * in the Java programming language.
983 * If the value is an SQL <code>NULL</code>,
984 * the driver returns a Java <code>null</code>.
985 * This method uses the specified <code>Map</code> object for
986 * custom mapping if appropriate.
987 *
988 * @param colName the name of the column from which to retrieve the value
989 * @param map a <code>java.util.Map</code> object that contains the mapping
990 * from SQL type names to classes in the Java programming language
991 * @return an <code>Object</code> representing the SQL value in the
992 * specified column
993 * @exception SQLException if a database access error occurs
994 * @since 1.2
995 *
996 */
997 public Object getObject(String colName, java.util.Map map) throws SQLException {
998 return null;
999 }
1000
1001 /** Retrieves the value of the designated column in the current row
1002 * of this <code>ResultSet</code> object as a <code>Ref</code> object
1003 * in the Java programming language.
1004 *
1005 * @param i the first column is 1, the second is 2, ...
1006 * @return a <code>Ref</code> object representing an SQL <code>REF</code>
1007 * value
1008 * @exception SQLException if a database access error occurs
1009 * @since 1.2
1010 *
1011 */
1012 public Ref getRef(int i) throws SQLException {
1013 return null;
1014 }
1015
1016 /** Retrieves the value of the designated column in the current row
1017 * of this <code>ResultSet</code> object as a <code>Ref</code> object
1018 * in the Java programming language.
1019 *
1020 * @param colName the column name
1021 * @return a <code>Ref</code> object representing the SQL <code>REF</code>
1022 * value in the specified column
1023 * @exception SQLException if a database access error occurs
1024 * @since 1.2
1025 *
1026 */
1027 public Ref getRef(String colName) throws SQLException {
1028 return null;
1029 }
1030
1031 /** Retrieves the current row number. The first row is number 1, the
1032 * second number 2, and so on.
1033 *
1034 * @return the current row number; <code>0</code> if there is no current row
1035 * @exception SQLException if a database access error occurs
1036 * @since 1.2
1037 *
1038 */
1039 public int getRow() throws SQLException {
1040 return 0;
1041 }
1042
1043 /** Retrieves the value of the designated column in the current row
1044 * of this <code>ResultSet</code> object as
1045 * a <code>short</code> in the Java programming language.
1046 *
1047 * @param columnName the SQL name of the column
1048 * @return the column value; if the value is SQL <code>NULL</code>, the
1049 * value returned is <code>0</code>
1050 * @exception SQLException if a database access error occurs
1051 *
1052 */
1053 public short getShort(String columnName) throws SQLException {
1054 return 0;
1055 }
1056
1057 /** Retrieves the value of the designated column in the current row
1058 * of this <code>ResultSet</code> object as
1059 * a <code>short</code> in the Java programming language.
1060 *
1061 * @param columnIndex the first column is 1, the second is 2, ...
1062 * @return the column value; if the value is SQL <code>NULL</code>, the
1063 * value returned is <code>0</code>
1064 * @exception SQLException if a database access error occurs
1065 *
1066 */
1067 public short getShort(int columnIndex) throws SQLException {
1068 return 0;
1069 }
1070
1071 /** Retrieves the <code>Statement</code> object that produced this
1072 * <code>ResultSet</code> object.
1073 * If the result set was generated some other way, such as by a
1074 * <code>DatabaseMetaData</code> method, this method returns
1075 * <code>null</code>.
1076 *
1077 * @return the <code>Statment</code> object that produced
1078 * this <code>ResultSet</code> object or <code>null</code>
1079 * if the result set was produced some other way
1080 * @exception SQLException if a database access error occurs
1081 * @since 1.2
1082 *
1083 */
1084 public java.sql.Statement getStatement() throws SQLException {
1085 return null;
1086 }
1087
1088 /** Retrieves the value of the designated column in the current row
1089 * of this <code>ResultSet</code> object as
1090 * a <code>String</code> in the Java programming language.
1091 *
1092 * @param columnName the SQL name of the column
1093 * @return the column value; if the value is SQL <code>NULL</code>, the
1094 * value returned is <code>null</code>
1095 * @exception SQLException if a database access error occurs
1096 *
1097 */
1098 public String getString(String columnName) throws SQLException {
1099 /* for(int x=0; x<resultTable.size(); x++){
1100 if(
1101 ((ResultColumn)resultTable.get(x)).columnName.toLowerCase().equals(columnName.toLowerCase())
1102 ){
1103 return ((ResultColumn)resultTable.get(x)).columnData.get(currentrow).toString();
1104 }
1105 }
1106 throw new SQLException("AResult::getString(String): column or selection past result set? " + columnName); */
1107 return getString(findColumn(columnName));
1108 }
1109
1110 /** Retrieves the value of the designated column in the current row
1111 * of this <code>ResultSet</code> object as
1112 * a <code>String</code> in the Java programming language.
1113 *
1114 * @param columnIndex the first column is 1, the second is 2, ...
1115 * @return the column value; if the value is SQL <code>NULL</code>, the
1116 * value returned is <code>null</code>
1117 * @exception SQLException if a database access error occurs
1118 *
1119 */
1120 public String getString(int columnIndex) throws SQLException {
1121 try{
1122 return ((ResultColumn)resultTable.get(columnIndex - 1)).columnData.get(currentrow).toString();
1123 }catch(Exception e){
1124 throw new SQLException("AResult::getString(int): column or selection past result set?" + columnIndex);
1125 }
1126 }
1127
1128 /** Retrieves the value of the designated column in the current row
1129 * of this <code>ResultSet</code> object as
1130 * a <code>java.sql.Time</code> object in the Java programming language.
1131 *
1132 * @param columnName the SQL name of the column
1133 * @return the column value;
1134 * if the value is SQL <code>NULL</code>,
1135 * the value returned is <code>null</code>
1136 * @exception SQLException if a database access error occurs
1137 *
1138 */
1139 public java.sql.Time getTime(String columnName) throws SQLException {
1140 return null;
1141 }
1142
1143 /** Retrieves the value of the designated column in the current row
1144 * of this <code>ResultSet</code> object as
1145 * a <code>java.sql.Time</code> object in the Java programming language.
1146 *
1147 * @param columnIndex the first column is 1, the second is 2, ...
1148 * @return the column value; if the value is SQL <code>NULL</code>, the
1149 * value returned is <code>null</code>
1150 * @exception SQLException if a database access error occurs
1151 *
1152 */
1153 public java.sql.Time getTime(int columnIndex) throws SQLException {
1154 return null;
1155 }
1156
1157 /** Retrieves the value of the designated column in the current row
1158 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
1159 * in the Java programming language.
1160 * This method uses the given calendar to construct an appropriate millisecond
1161 * value for the time if the underlying database does not store
1162 * timezone information.
1163 *
1164 * @param columnName the SQL name of the column
1165 * @param cal the <code>java.util.Calendar</code> object
1166 * to use in constructing the time
1167 * @return the column value as a <code>java.sql.Time</code> object;
1168 * if the value is SQL <code>NULL</code>,
1169 * the value returned is <code>null</code> in the Java programming language
1170 * @exception SQLException if a database access error occurs
1171 * @since 1.2
1172 *
1173 */
1174 public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
1175 return null;
1176 }
1177
1178 /** Retrieves the value of the designated column in the current row
1179 * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
1180 * in the Java programming language.
1181 * This method uses the given calendar to construct an appropriate millisecond
1182 * value for the time if the underlying database does not store
1183 * timezone information.
1184 *
1185 * @param columnIndex the first column is 1, the second is 2, ...
1186 * @param cal the <code>java.util.Calendar</code> object
1187 * to use in constructing the time
1188 * @return the column value as a <code>java.sql.Time</code> object;
1189 * if the value is SQL <code>NULL</code>,
1190 * the value returned is <code>null</code> in the Java programming language
1191 * @exception SQLException if a database access error occurs
1192 * @since 1.2
1193 *
1194 */
1195 public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
1196 return null;
1197 }
1198
1199 /** Retrieves the value of the designated column in the current row
1200 * of this <code>ResultSet</code> object as
1201 * a <code>java.sql.Timestamp</code> object.
1202 *
1203 * @param columnName the SQL name of the column
1204 * @return the column value; if the value is SQL <code>NULL</code>, the
1205 * value returned is <code>null</code>
1206 * @exception SQLException if a database access error occurs
1207 *
1208 */
1209 public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
1210 return null;
1211 }
1212
1213 /** Retrieves the value of the designated column in the current row
1214 * of this <code>ResultSet</code> object as
1215 * a <code>java.sql.Timestamp</code> object in the Java programming language.
1216 *
1217 * @param columnIndex the first column is 1, the second is 2, ...
1218 * @return the column value; if the value is SQL <code>NULL</code>, the
1219 * value returned is <code>null</code>
1220 * @exception SQLException if a database access error occurs
1221 *
1222 */
1223 public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
1224 return null;
1225 }
1226
1227 /** Retrieves the value of the designated column in the current row
1228 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
1229 * in the Java programming language.
1230 * This method uses the given calendar to construct an appropriate millisecond
1231 * value for the timestamp if the underlying database does not store
1232 * timezone information.
1233 *
1234 * @param columnName the SQL name of the column
1235 * @param cal the <code>java.util.Calendar</code> object
1236 * to use in constructing the date
1237 * @return the column value as a <code>java.sql.Timestamp</code> object;
1238 * if the value is SQL <code>NULL</code>,
1239 * the value returned is <code>null</code> in the Java programming language
1240 * @exception SQLException if a database access error occurs
1241 * @since 1.2
1242 *
1243 */
1244 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
1245 return null;
1246 }
1247
1248 /** Retrieves the value of the designated column in the current row
1249 * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
1250 * in the Java programming language.
1251 * This method uses the given calendar to construct an appropriate millisecond
1252 * value for the timestamp if the underlying database does not store
1253 * timezone information.
1254 *
1255 * @param columnIndex the first column is 1, the second is 2, ...
1256 * @param cal the <code>java.util.Calendar</code> object
1257 * to use in constructing the timestamp
1258 * @return the column value as a <code>java.sql.Timestamp</code> object;
1259 * if the value is SQL <code>NULL</code>,
1260 * the value returned is <code>null</code> in the Java programming language
1261 * @exception SQLException if a database access error occurs
1262 * @since 1.2
1263 *
1264 */
1265 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
1266 return null;
1267 }
1268
1269 /** Retrieves the type of this <code>ResultSet</code> object.
1270 * The type is determined by the <code>Statement</code> object
1271 * that created the result set.
1272 *
1273 * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
1274 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
1275 * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
1276 * @exception SQLException if a database access error occurs
1277 * @since 1.2
1278 *
1279 */
1280 public int getType() throws SQLException {
1281 return 0;
1282 }
1283
1284 /** Retrieves the value of the designated column in the current row
1285 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
1286 * object in the Java programming language.
1287 *
1288 * @param columnIndex the index of the column 1 is the first, 2 is the second,...
1289 * @return the column value as a <code>java.net.URL</code> object;
1290 * if the value is SQL <code>NULL</code>,
1291 * the value returned is <code>null</code> in the Java programming language
1292 * @exception SQLException if a database access error occurs,
1293 * or if a URL is malformed
1294 * @since 1.4
1295 *
1296 */
1297 public java.net.URL getURL(int columnIndex) throws SQLException {
1298 return null;
1299 }
1300
1301 /** Retrieves the value of the designated column in the current row
1302 * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
1303 * object in the Java programming language.
1304 *
1305 * @param columnName the SQL name of the column
1306 * @return the column value as a <code>java.net.URL</code> object;
1307 * if the value is SQL <code>NULL</code>,
1308 * the value returned is <code>null</code> in the Java programming language
1309 * @exception SQLException if a database access error occurs
1310 * or if a URL is malformed
1311 * @since 1.4
1312 *
1313 */
1314 public java.net.URL getURL(String columnName) throws SQLException {
1315 return null;
1316 }
1317
1318 /** Retrieves the value of the designated column in the current row
1319 * of this <code>ResultSet</code> object as a stream of two-byte
1320 * Unicode characters. The first byte is the high byte; the second
1321 * byte is the low byte.
1322 *
1323 * The value can then be read in chunks from the
1324 * stream. This method is particularly
1325 * suitable for retrieving large <code>LONGVARCHAR</code> values.
1326 * The JDBC technology-enabled driver will
1327 * do any necessary conversion from the database format into Unicode.
1328 *
1329 * <P><B>Note:</B> All the data in the returned stream must be
1330 * read prior to getting the value of any other column. The next
1331 * call to a getter method implicitly closes the stream.
1332 * Also, a stream may return <code>0</code> when the method
1333 * <code>InputStream.available</code> is called, whether there
1334 * is data available or not.
1335 *
1336 * @param columnName the SQL name of the column
1337 * @return a Java input stream that delivers the database column value
1338 * as a stream of two-byte Unicode characters.
1339 * If the value is SQL <code>NULL</code>, the value returned
1340 * is <code>null</code>.
1341 * @exception SQLException if a database access error occurs
1342 * @deprecated use <code>getCharacterStream</code> instead
1343 *
1344 */
1345 public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
1346 return null;
1347 }
1348
1349 /** Retrieves the value of the designated column in the current row
1350 * of this <code>ResultSet</code> object as
1351 * as a stream of two-byte Unicode characters. The first byte is
1352 * the high byte; the second byte is the low byte.
1353 *
1354 * The value can then be read in chunks from the
1355 * stream. This method is particularly
1356 * suitable for retrieving large <code>LONGVARCHAR</code>values. The
1357 * JDBC driver will do any necessary conversion from the database
1358 * format into Unicode.
1359 *
1360 * <P><B>Note:</B> All the data in the returned stream must be
1361 * read prior to getting the value of any other column. The next
1362 * call to a getter method implicitly closes the stream.
1363 * Also, a stream may return <code>0</code> when the method
1364 * <code>InputStream.available</code>
1365 * is called, whether there is data available or not.
1366 *
1367 * @param columnIndex the first column is 1, the second is 2, ...
1368 * @return a Java input stream that delivers the database column value
1369 * as a stream of two-byte Unicode characters;
1370 * if the value is SQL <code>NULL</code>, the value returned is
1371 * <code>null</code>
1372 *
1373 * @exception SQLException if a database access error occurs
1374 * @deprecated use <code>getCharacterStream</code> in place of
1375 * <code>getUnicodeStream</code>
1376 *
1377 */
1378 public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
1379 return null;
1380 }
1381
1382 /** Retrieves the first warning reported by calls on this
1383 * <code>ResultSet</code> object.
1384 * Subsequent warnings on this <code>ResultSet</code> object
1385 * will be chained to the <code>SQLWarning</code> object that
1386 * this method returns.
1387 *
1388 * <P>The warning chain is automatically cleared each time a new
1389 * row is read. This method may not be called on a <code>ResultSet</code>
1390 * object that has been closed; doing so will cause an
1391 * <code>SQLException</code> to be thrown.
1392 * <P>
1393 * <B>Note:</B> This warning chain only covers warnings caused
1394 * by <code>ResultSet</code> methods. Any warning caused by
1395 * <code>Statement</code> methods
1396 * (such as reading OUT parameters) will be chained on the
1397 * <code>Statement</code> object.
1398 *
1399 * @return the first <code>SQLWarning</code> object reported or
1400 * <code>null</code> if there are none
1401 * @exception SQLException if a database access error occurs or this method is
1402 * called on a closed result set
1403 *
1404 */
1405 public SQLWarning getWarnings() throws SQLException {
1406 return null;
1407 }
1408
1409 /** Inserts the contents of the insert row into this
1410 * <code>ResultSet</code> object and into the database.
1411 * The cursor must be on the insert row when this method is called.
1412 *
1413 * @exception SQLException if a database access error occurs,
1414 * if this method is called when the cursor is not on the insert row,
1415 * or if not all of non-nullable columns in
1416 * the insert row have been given a value
1417 * @since 1.2
1418 *
1419 */
1420 public void insertRow() throws SQLException {
1421 }
1422
1423 /** Retrieves whether the cursor is after the last row in
1424 * this <code>ResultSet</code> object.
1425 *
1426 * @return <code>true</code> if th