Source for java.sql.ResultSet

   1: /* ResultSet.java -- A SQL statement result set.
   2:    Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10:  
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package java.sql;
  40: 
  41: import java.io.InputStream;
  42: import java.io.Reader;
  43: import java.math.BigDecimal;
  44: import java.net.URL;
  45: import java.util.Calendar;
  46: import java.util.Map;
  47: 
  48: /**
  49:  * This interface provides access to the data set returned by a SQL
  50:  * statement.  An instance of this interface is returned by the various
  51:  * execution methods in the <code>Statement</code>.
  52:  *
  53:  * <p> This class models a cursor, which can be stepped through one row at a
  54:  * time.  Methods are provided for accessing columns by column name or by
  55:  * index.</p>
  56:  *
  57:  * <p> Note that a result set is invalidated if the statement that returned
  58:  * it is closed.</p>
  59:  *
  60:  * @author Aaron M. Renn (arenn@urbanophile.com)
  61:  */
  62: public interface ResultSet 
  63: {
  64:   /**
  65:    * The rows will be processed in order from first to last.
  66:    */
  67:   int FETCH_FORWARD = 1000;
  68: 
  69:   /**
  70:    * The rows will be processed in order from last to first.
  71:    */
  72:   int FETCH_REVERSE = 1001;
  73: 
  74:   /**
  75:    * The rows will be processed in an unknown order
  76:    */
  77:   int FETCH_UNKNOWN = 1002;
  78: 
  79:   /**
  80:    * This type of result set may only step forward through the rows returned.
  81:    */
  82:   int TYPE_FORWARD_ONLY = 1003;
  83: 
  84:   /**
  85:    * This type of result set is scrollable and is not sensitive to changes
  86:    * made by other statements.
  87:    */
  88:   int TYPE_SCROLL_INSENSITIVE = 1004;
  89: 
  90:   /**
  91:    * This type of result set is scrollable and is also sensitive to changes
  92:    * made by other statements.
  93:    */
  94:   int TYPE_SCROLL_SENSITIVE = 1005;
  95: 
  96:   /**
  97:    * The concurrency mode of for the result set may not be modified.
  98:    */
  99:   int CONCUR_READ_ONLY = 1007;
 100: 
 101:   /**
 102:    * The concurrency mode of for the result set may be modified.
 103:    */
 104:   int CONCUR_UPDATABLE = 1008;
 105: 
 106:   int HOLD_CURSORS_OVER_COMMIT = 1;
 107: 
 108:   int CLOSE_CURSORS_AT_COMMIT = 2;
 109: 
 110:   /**
 111:    * This method advances to the next row in the result set.  Any streams
 112:    * open on the current row are closed automatically.
 113:    *
 114:    * @return <code>true</code> if the next row exists, <code>false</code>
 115:    *         otherwise.
 116:    * @exception SQLException If an error occurs.
 117:    */
 118:   boolean next() throws SQLException;
 119: 
 120:   /**
 121:    * This method closes the result set and frees any associated resources.
 122:    * 
 123:    * @exception SQLException If an error occurs.
 124:    */
 125:   void close() throws SQLException;
 126: 
 127:   /**
 128:    * This method tests whether the value of the last column that was fetched
 129:    * was actually a SQL NULL value.
 130:    *
 131:    * @return <code>true</code> if the last column fetched was a NULL,
 132:    *         <code>false</code> otherwise.
 133:    * @exception SQLException If an error occurs.
 134:    */
 135:   boolean wasNull() throws SQLException;
 136: 
 137:   /**
 138:    * This method returns the value of the specified column as a Java
 139:    * <code>String</code>.
 140:    *
 141:    * @param index The index of the column to return.
 142:    * @return The column value as a <code>String</code>.
 143:    * @exception SQLException If an error occurs.
 144:    */
 145:   String getString(int columnIndex) throws SQLException;
 146: 
 147:   /**
 148:    * This method returns the value of the specified column as a Java
 149:    * <code>boolean</code>.
 150:    *
 151:    * @param index The index of the column to return.
 152:    * @return The column value as a <code>boolean</code>.
 153:    * @exception SQLException If an error occurs.
 154:    */
 155:   boolean getBoolean(int columnIndex) throws SQLException;
 156: 
 157:   /**
 158:    * This method returns the value of the specified column as a Java
 159:    * <code>byte</code>.
 160:    *
 161:    * @param index The index of the column to return.
 162:    * @return The column value as a <code>byte</code>.
 163:    * @exception SQLException If an error occurs.
 164:    */
 165:   byte getByte(int columnIndex) throws SQLException;
 166: 
 167:   /**
 168:    * This method returns the value of the specified column as a Java
 169:    * <code>short</code>.
 170:    *
 171:    * @param index The index of the column to return.
 172:    * @return The column value as a <code>short</code>.
 173:    * @exception SQLException If an error occurs.
 174:    */
 175:   short getShort(int columnIndex) throws SQLException;
 176: 
 177:   /**
 178:    * This method returns the value of the specified column as a Java
 179:    * <code>int</code>.
 180:    *
 181:    * @param index The index of the column to return.
 182:    * @return The column value as a <code>int</code>.
 183:    * @exception SQLException If an error occurs.
 184:    */
 185:   int getInt(int columnIndex) throws SQLException;
 186: 
 187:   /**
 188:    * This method returns the value of the specified column as a Java
 189:    * <code>long</code>.
 190:    *
 191:    * @param index The index of the column to return.
 192:    * @return The column value as a <code>long</code>.
 193:    * @exception SQLException If an error occurs.
 194:    */
 195:   long getLong(int columnIndex) throws SQLException;
 196: 
 197:   /**
 198:    * This method returns the value of the specified column as a Java
 199:    * <code>float</code>.
 200:    *
 201:    * @param index The index of the column to return.
 202:    * @return The column value as a <code>float</code>.
 203:    * @exception SQLException If an error occurs.
 204:    */
 205:   float getFloat(int columnIndex) throws SQLException;
 206: 
 207:   /**
 208:    * This method returns the value of the specified column as a Java
 209:    * <code>double</code>.
 210:    *
 211:    * @param index The index of the column to return.
 212:    * @return The column value as a <code>double</code>.
 213:    * @exception SQLException If an error occurs.
 214:    */
 215:   double getDouble(int columnIndex) throws SQLException;
 216: 
 217:   /**
 218:    * This method returns the value of the specified column as a Java
 219:    * <code>BigDecimal</code>.
 220:    *
 221:    * @param index The index of the column to return.
 222:    * @param scale The number of digits to the right of the decimal to return.
 223:    * @return The column value as a <code>BigDecimal</code>.
 224:    * @exception SQLException If an error occurs.
 225:    * @deprecated
 226:    */
 227:   BigDecimal getBigDecimal(int columnIndex, int scale)
 228:     throws SQLException;
 229: 
 230:   /**
 231:    * This method returns the value of the specified column as a Java
 232:    * byte array.
 233:    *
 234:    * @param index The index of the column to return.
 235:    * @return The column value as a byte array
 236:    * @exception SQLException If an error occurs.
 237:    */
 238:   byte[] getBytes(int columnIndex) throws SQLException;
 239: 
 240:   /**
 241:    * This method returns the value of the specified column as a Java
 242:    * <code>java.sql.Date</code>.
 243:    *
 244:    * @param index The index of the column to return.
 245:    * @return The column value as a <code>java.sql.Date</code>.
 246:    * @exception SQLException If an error occurs.
 247:    */
 248:   Date getDate(int columnIndex) throws SQLException;
 249: 
 250:   /**
 251:    * This method returns the value of the specified column as a Java
 252:    * <code>java.sql.Time</code>.
 253:    *
 254:    * @param index The index of the column to return.
 255:    * @return The column value as a <code>java.sql.Time</code>.
 256:    * @exception SQLException If an error occurs.
 257:    */
 258:   Time getTime(int columnIndex) throws SQLException;
 259: 
 260:   /**
 261:    * This method returns the value of the specified column as a Java
 262:    * <code>java.sql.Timestamp</code>.
 263:    *
 264:    * @param index The index of the column to return.
 265:    * @return The column value as a <code>java.sql.Timestamp</code>.
 266:    * @exception SQLException If an error occurs.
 267:    */
 268:   Timestamp getTimestamp(int columnIndex) throws SQLException;
 269: 
 270:   /**
 271:    * This method returns the value of the specified column as an ASCII 
 272:    * stream.  Note that all the data from this stream must be read before
 273:    * fetching the value of any other column.  Please also be aware that 
 274:    * calling <code>next()</code> or <code>close()</code> on this result set
 275:    * will close this stream as well.
 276:    *
 277:    * @param index The index of the column to return.
 278:    * @return The column value as an ASCII <code>InputStream</code>.
 279:    * @exception SQLException If an error occurs.
 280:    */
 281:   InputStream getAsciiStream(int columnIndex) throws SQLException;
 282: 
 283:   /**
 284:    * This method returns the value of the specified column as a Unicode UTF-8
 285:    * stream.  Note that all the data from this stream must be read before
 286:    * fetching the value of any other column.  Please also be aware that 
 287:    * calling <code>next()</code> or <code>close()</code> on this result set
 288:    * will close this stream as well.
 289:    *
 290:    * @param index The index of the column to return.
 291:    * @return The column value as a Unicode UTF-8 <code>InputStream</code>.
 292:    * @exception SQLException If an error occurs.
 293:    * @deprecated Use getCharacterStream instead.
 294:    */
 295:   InputStream getUnicodeStream(int columnIndex) throws SQLException;
 296: 
 297:   /**
 298:    * This method returns the value of the specified column as a raw byte
 299:    * stream.  Note that all the data from this stream must be read before
 300:    * fetching the value of any other column.  Please also be aware that 
 301:    * calling <code>next()</code> or <code>close()</code> on this result set
 302:    * will close this stream as well.
 303:    *
 304:    * @param index The index of the column to return.
 305:    * @return The column value as a raw byte <code>InputStream</code>.
 306:    * @exception SQLException If an error occurs.
 307:    */
 308:   InputStream getBinaryStream(int columnIndex) throws SQLException;
 309: 
 310:   /**
 311:    * This method returns the value of the specified column as a Java
 312:    * <code>String</code>.
 313:    *
 314:    * @param column The name of the column to return.
 315:    * @return The column value as a <code>String</code>.
 316:    * @exception SQLException If an error occurs.
 317:    */
 318:   String getString(String columnName) throws SQLException;
 319: 
 320:   /**
 321:    * This method returns the value of the specified column as a Java
 322:    * <code>boolean</code>.
 323:    *
 324:    * @param column The name of the column to return.
 325:    * @return The column value as a <code>boolean</code>.
 326:    * @exception SQLException If an error occurs.
 327:    */
 328:   boolean getBoolean(String columnName) throws SQLException;
 329: 
 330:   /**
 331:    * This method returns the value of the specified column as a Java
 332:    * <code>byte</code>.
 333:    *
 334:    * @param column The name of the column to return.
 335:    * @return The column value as a <code>byte</code>.
 336:    * @exception SQLException If an error occurs.
 337:    */
 338:   byte getByte(String columnName) throws SQLException;
 339: 
 340:   /**
 341:    * This method returns the value of the specified column as a Java
 342:    * <code>short</code>.
 343:    *
 344:    * @param column The name of the column to return.
 345:    * @return The column value as a <code>short</code>.
 346:    * @exception SQLException If an error occurs.
 347:    */
 348:   short getShort(String columnName) throws SQLException;
 349: 
 350:   /**
 351:    * This method returns the value of the specified column as a Java
 352:    * <code>int</code>.
 353:    *
 354:    * @param column The name of the column to return.
 355:    * @return The column value as a <code>int</code>.
 356:    * @exception SQLException If an error occurs.
 357:    */
 358:   int getInt(String columnName) throws SQLException;
 359: 
 360:   /**
 361:    * This method returns the value of the specified column as a Java
 362:    * <code>long</code>.
 363:    *
 364:    * @param column The name of the column to return.
 365:    * @return The column value as a <code>long</code>.
 366:    * @exception SQLException If an error occurs.
 367:    */
 368:   long getLong(String columnName) throws SQLException;
 369: 
 370:   /**
 371:    * This method returns the value of the specified column as a Java
 372:    * <code>float</code>.
 373:    *
 374:    * @param column The name of the column to return.
 375:    * @return The column value as a <code>float</code>.
 376:    * @exception SQLException If an error occurs.
 377:    */
 378:   float getFloat(String columnName) throws SQLException;
 379: 
 380:   /**
 381:    * This method returns the value of the specified column as a Java
 382:    * <code>double</code>.
 383:    *
 384:    * @param column The name of the column to return.
 385:    * @return The column value as a <code>double</code>.
 386:    * @exception SQLException If an error occurs.
 387:    */
 388:   double getDouble(String columnName) throws SQLException;
 389: 
 390:   /**
 391:    * This method returns the value of the specified column as a Java
 392:    * <code>BigDecimal</code>.
 393:    *
 394:    * @param index The index of the column to return.
 395:    * @return The column value as a <code>BigDecimal</code>.
 396:    * @exception SQLException If an error occurs.
 397:    * @deprecated
 398:    */
 399:   BigDecimal getBigDecimal(String columnName, int scale)
 400:     throws SQLException;
 401: 
 402:   /**
 403:    * This method returns the value of the specified column as a Java
 404:    * byte array.
 405:    *
 406:    * @param column The name of the column to return.
 407:    * @return The column value as a byte array
 408:    * @exception SQLException If an error occurs.
 409:    */
 410:   byte[] getBytes(String columnName) throws SQLException;
 411: 
 412:   /**
 413:    * This method returns the value of the specified column as a Java
 414:    * <code>java.sql.Date</code>.
 415:    *
 416:    * @param column The name of the column to return.
 417:    * @return The column value as a <code>java.sql.Date</code>.
 418:    * @exception SQLException If an error occurs.
 419:    */
 420:   Date getDate(String columnName) throws SQLException;
 421: 
 422:   /**
 423:    * This method returns the value of the specified column as a Java
 424:    * <code>java.sql.Time</code>.
 425:    *
 426:    * @param column The name of the column to return.
 427:    * @return The column value as a <code>java.sql.Time</code>.
 428:    * @exception SQLException If an error occurs.
 429:    */
 430:   Time getTime(String columnName) throws SQLException;
 431: 
 432:   /**
 433:    * This method returns the value of the specified column as a Java
 434:    * <code>java.sql.Timestamp</code>.
 435:    *
 436:    * @param column The name of the column to return.
 437:    * @return The column value as a <code>java.sql.Timestamp</code>.
 438:    * @exception SQLException If an error occurs.
 439:    */
 440:   Timestamp getTimestamp(String columnName) throws SQLException;
 441: 
 442:   /**
 443:    * This method returns the value of the specified column as an ASCII 
 444:    * stream.  Note that all the data from this stream must be read before
 445:    * fetching the value of any other column.  Please also be aware that 
 446:    * calling <code>next()</code> or <code>close()</code> on this result set
 447:    * will close this stream as well.
 448:    *
 449:    * @param column The name of the column to return.
 450:    * @return The column value as an ASCII <code>InputStream</code>.
 451:    * @exception SQLException If an error occurs.
 452:    */
 453:   InputStream getAsciiStream(String columnName) throws SQLException;
 454: 
 455:   /**
 456:    * This method returns the value of the specified column as a Unicode UTF-8
 457:    * stream.  Note that all the data from this stream must be read before
 458:    * fetching the value of any other column.  Please also be aware that 
 459:    * calling <code>next()</code> or <code>close()</code> on this result set
 460:    * will close this stream as well.
 461:    *
 462:    * @param column The name of the column to return.
 463:    * @return The column value as a Unicode UTF-8 <code>InputStream</code>.
 464:    * @exception SQLException If an error occurs.
 465:    * @deprecated Use getCharacterStream instead.
 466:    */
 467:   InputStream getUnicodeStream(String columnName) throws SQLException;
 468: 
 469:   /**
 470:    * This method returns the value of the specified column as a raw byte
 471:    * stream.  Note that all the data from this stream must be read before
 472:    * fetching the value of any other column.  Please also be aware that 
 473:    * calling <code>next()</code> or <code>close()</code> on this result set
 474:    * will close this stream as well.
 475:    *
 476:    * @param column The name of the column to return.
 477:    * @return The column value as a raw byte <code>InputStream</code>.
 478:    * @exception SQLException If an error occurs.
 479:    */
 480:   InputStream getBinaryStream(String columnName) throws SQLException;
 481: 
 482:   /**
 483:    * This method returns the first SQL warning associated with this result
 484:    * set.  Any additional warnings will be chained to this one.
 485:    *
 486:    * @return The first SQLWarning for this result set, or <code>null</code> if
 487:    *         there are no warnings.
 488:    * @exception SQLException If an error occurs.
 489:    */
 490:   SQLWarning getWarnings() throws SQLException;
 491: 
 492:   /**
 493:    * This method clears all warnings associated with this result set.
 494:    *
 495:    * @exception SQLException If an error occurs.
 496:    */
 497:   void clearWarnings() throws SQLException;
 498: 
 499:   /**
 500:    * This method returns the name of the database cursor used by this
 501:    * result set.
 502:    *
 503:    * @return The name of the database cursor used by this result set.
 504:    * @exception SQLException If an error occurs.
 505:    */
 506:   String getCursorName() throws SQLException;
 507: 
 508:   /**
 509:    * This method returns data about the columns returned as part of the
 510:    * result set as a <code>ResultSetMetaData</code> instance.
 511:    *
 512:    * @return The <code>ResultSetMetaData</code> instance for this result set.
 513:    * @exception SQLException If an error occurs.
 514:    */
 515:   ResultSetMetaData getMetaData() throws SQLException;
 516: 
 517:   /**
 518:    * This method returns the value of the specified column as a Java
 519:    * <code>Object</code>.
 520:    *
 521:    * @param index The index of the column to return.
 522:    * @return The column value as an <code>Object</code>.
 523:    * @exception SQLException If an error occurs.
 524:    */
 525:   Object getObject(int columnIndex) throws SQLException;
 526: 
 527:   /**
 528:    * This method returns the value of the specified column as a Java
 529:    * <code>Object</code>.
 530:    *
 531:    * @param column The name of the column to return.
 532:    * @return The column value as an <code>Object</code>.
 533:    * @exception SQLException If an error occurs.
 534:    */
 535:   Object getObject(String columnName) throws SQLException;
 536: 
 537:   /**
 538:    * This method returns the column index of the specified named column.
 539:    *
 540:    * @param column The name of the column.
 541:    * @return The index of the column.
 542:    * @exception SQLException If an error occurs.
 543:    */
 544:   int findColumn(String columnName) throws SQLException;
 545: 
 546:   /**
 547:    * This method returns the value of the specified column as a character
 548:    * stream.  Note that all the data from this stream must be read before
 549:    * fetching the value of any other column.  Please also be aware that 
 550:    * calling <code>next()</code> or <code>close()</code> on this result set
 551:    * will close this stream as well.
 552:    *
 553:    * @param index The index of the column to return.
 554:    * @return The column value as an character <code>Reader</code>.
 555:    * @exception SQLException If an error occurs.
 556:    */
 557:   Reader getCharacterStream(int columnIndex) throws SQLException;
 558: 
 559:   /**
 560:    * This method returns the value of the specified column as a character
 561:    * stream.  Note that all the data from this stream must be read before
 562:    * fetching the value of any other column.  Please also be aware that 
 563:    * calling <code>next()</code> or <code>close()</code> on this result set
 564:    * will close this stream as well.
 565:    *
 566:    * @param column The name of the column to return.
 567:    * @return The column value as an character <code>Reader</code>.
 568:    * @exception SQLException If an error occurs.
 569:    */
 570:   Reader getCharacterStream(String columnName) throws SQLException;
 571: 
 572:   /**
 573:    * This method returns the value of the specified column as a Java
 574:    * <code>BigDecimal</code>.
 575:    *
 576:    * @param index The index of the column to return.
 577:    * @return The column value as a <code>BigDecimal</code>.
 578:    * @exception SQLException If an error occurs.
 579:    */
 580:   BigDecimal getBigDecimal(int columnIndex) throws SQLException;
 581: 
 582:   /**
 583:    * This method returns the value of the specified column as a Java
 584:    * <code>BigDecimal</code>.
 585:    *
 586:    * @param column The name of the column to return.
 587:    * @return The column value as a <code>BigDecimal</code>.
 588:    * @exception SQLException If an error occurs.
 589:    */
 590:   BigDecimal getBigDecimal(String columnName) throws SQLException;
 591: 
 592:   /**
 593:    * This method tests whether or not the cursor is before the first row
 594:    * in the result set.
 595:    *
 596:    * @return <code>true</code> if the cursor is positioned before the first
 597:    *         row, <code>false</code> otherwise.
 598:    * @exception SQLException If an error occurs.
 599:    */
 600:   boolean isBeforeFirst() throws SQLException;
 601: 
 602:   /**
 603:    * This method tests whether or not the cursor is after the last row
 604:    * in the result set.
 605:    *
 606:    * @return <code>true</code> if the cursor is positioned after the last
 607:    *         row, <code>false</code> otherwise.
 608:    * @exception SQLException If an error occurs.
 609:    */
 610:   boolean isAfterLast() throws SQLException;
 611: 
 612:   /**
 613:    * This method tests whether or not the cursor is positioned on the first
 614:    * row in the result set.
 615:    *
 616:    * @return <code>true</code> if the cursor is positioned on the first
 617:    *         row, <code>false</code> otherwise.
 618:    * @exception SQLException If an error occurs.
 619:    */
 620:   boolean isFirst() throws SQLException;
 621: 
 622:   /**
 623:    * This method tests whether or not the cursor is on the last row
 624:    * in the result set.
 625:    *
 626:    * @return <code>true</code> if the cursor is positioned on the last
 627:    *         row, <code>false</code> otherwise.
 628:    * @exception SQLException If an error occurs.
 629:    */
 630:   boolean isLast() throws SQLException;
 631: 
 632:   /**
 633:    * This method repositions the cursor to before the first row in the
 634:    * result set.
 635:    * 
 636:    * @exception SQLException If an error occurs.
 637:    */
 638:   void beforeFirst() throws SQLException;
 639: 
 640:   /**
 641:    * This method repositions the cursor to after the last row in the result
 642:    * set.
 643:    * 
 644:    * @exception SQLException If an error occurs.
 645:    */
 646:   void afterLast() throws SQLException;
 647: 
 648:   /**
 649:    * This method repositions the cursor on the first row in the
 650:    * result set.
 651:    *
 652:    * @return <code>true</code> if the cursor is on a valid row;
 653:    *         <code>false</code> if there are no rows in the result set.
 654:    * @exception SQLException If an error occurs.
 655:    */
 656:   boolean first() throws SQLException;
 657: 
 658:   /**
 659:    * This method repositions the cursor on the last row in the result
 660:    * set.
 661:    * 
 662:    * @return <code>true</code> if the cursor is on a valid row;
 663:    *         <code>false</code> if there are no rows in the result set.
 664:    * @exception SQLException If an error occurs.
 665:    */
 666:   boolean last() throws SQLException;
 667: 
 668:   /**
 669:    * This method returns the current row number in the cursor.  Numbering
 670:    * begins at index 1.
 671:    *
 672:    * @return The current row number, or 0 if there is not current row.
 673:    * @exception SQLException If an error occurs.
 674:    */
 675:   int getRow() throws SQLException;
 676: 
 677:   /**
 678:    * This method positions the result set to the specified absolute row.
 679:    * Positive numbers are row offsets from the beginning of the result
 680:    * set (numbering starts from row 1) and negative numbers are row offsets
 681:    * from the end of the result set (numbering starts from -1).
 682:    *
 683:    * @param row The row to position the result set to.
 684:    *
 685:    * @return <code>true</code> if the current position was changed,
 686:    *         <code>false</code> otherwise.
 687:    * @exception SQLException If an error occurs.
 688:    */
 689:   boolean absolute(int row) throws SQLException;
 690: 
 691:   /**
 692:    * This method moves the result set position relative to the current row.
 693:    * The offset can be positive or negative.
 694:    *
 695:    * @param row The relative row position to move to.
 696:    * @return <code>true</code> if the current position was changed,
 697:    *         <code>false</code> otherwise.
 698:    * @exception SQLException If an error occurs.
 699:    */
 700:   boolean relative(int rows) throws SQLException;
 701: 
 702:   /**
 703:    * This method moves the current position to the previous row in the
 704:    * result set.
 705:    *
 706:    * @return <code>true</code> if the previous row exists, <code>false</code>
 707:    *         otherwise.
 708:    * @exception SQLException If an error occurs.
 709:    */
 710:   boolean previous() throws SQLException;
 711: 
 712:   /**
 713:    * This method provides a hint to the driver about which direction the
 714:    * result set will be processed in. 
 715:    *
 716:    * @param direction The direction in which rows will be processed. (Values?)
 717:    * @exception SQLException If an error occurs.
 718:    */
 719:   void setFetchDirection(int direction) throws SQLException;
 720: 
 721:   /**
 722:    * This method returns the current fetch direction for this result set.
 723:    *
 724:    * @return The fetch direction for this result set.
 725:    * @exception SQLException If an error occurs.
 726:    */
 727:   int getFetchDirection() throws SQLException;
 728: 
 729:   /**
 730:    * This method provides a hint to the driver about how many rows at a
 731:    * time it should fetch from the database.
 732:    *
 733:    * @param rows The number of rows the driver should fetch per call.
 734:    * @exception SQLException If an error occurs.
 735:    */
 736:   void setFetchSize(int rows) throws SQLException;
 737: 
 738:   /**
 739:    * This method returns the current number of rows that will be fetched 
 740:    * from the database at a time.
 741:    *
 742:    * @return The current fetch size for this result set.
 743:    * @exception SQLException If an error occurs.
 744:    */
 745:   int getFetchSize() throws SQLException;
 746: 
 747:   /**
 748:    * This method returns the result set type of this result set.  This will
 749:    * be one of the TYPE_* constants defined in this interface.
 750:    *
 751:    * @return The result set type.
 752:    * @exception SQLException If an error occurs.
 753:    */
 754:   int getType() throws SQLException;
 755: 
 756:   /**
 757:    * This method returns the concurrency type of this result set.  This will
 758:    * be one of the CONCUR_* constants defined in this interface.
 759:    *
 760:    * @return The result set concurrency type.
 761:    * @exception SQLException If an error occurs.
 762:    */
 763:   int getConcurrency() throws SQLException;
 764: 
 765:   /**
 766:    * This method tests whether or not the current row in the result set
 767:    * has been updated.  Updates must be visible in order of this method to
 768:    * detect the update.
 769:    *
 770:    * @return <code>true</code> if the row has been updated, <code>false</code>
 771:    *         otherwise.
 772:    * @exception SQLException If an error occurs.
 773:    */
 774:   boolean rowUpdated() throws SQLException;
 775: 
 776:   /**
 777:    * This method tests whether or not the current row in the result set
 778:    * has been inserted.  Inserts must be visible in order of this method to
 779:    * detect the insert.
 780:    *
 781:    * @return <code>true</code> if the row has been inserted, <code>false</code>
 782:    *         otherwise.
 783:    * @exception SQLException If an error occurs.
 784:    */
 785:   boolean rowInserted() throws SQLException;
 786: 
 787:   /**
 788:    * This method tests whether or not the current row in the result set
 789:    * has been deleted.  Deletes must be visible in order of this method to
 790:    * detect the deletion.
 791:    *
 792:    * @return <code>true</code> if the row has been deleted, <code>false</code>
 793:    *         otherwise.
 794:    * @exception SQLException If an error occurs.
 795:    */
 796:   boolean rowDeleted() throws SQLException;
 797: 
 798:   /**
 799:    * This method updates the specified column to have a NULL value.  This
 800:    * does not update the actual database.  <code>updateRow</code> must be
 801:    * called in order to do that.
 802:    *
 803:    * @return index The index of the column to update.
 804:    * @exception SQLException If an error occurs.
 805:    */
 806:   void updateNull(int columnIndex) throws SQLException;
 807: 
 808:   /**
 809:    * This method updates the specified column to have a boolean value.  This
 810:    * does not update the actual database.  <code>updateRow</code> must be
 811:    * called in order to do that.
 812:    *
 813:    * @param index The index of the column to update.
 814:    * @param value The new value of the column.
 815:    * @exception SQLException If an error occurs.
 816:    */
 817:   void updateBoolean(int columnIndex, boolean x) throws SQLException;
 818: 
 819:   /**
 820:    * This method updates the specified column to have a byte value.  This
 821:    * does not update the actual database.  <code>updateRow</code> must be
 822:    * called in order to do that.
 823:    *
 824:    * @param index The index of the column to update.
 825:    * @param value The new value of the column.
 826:    * @exception SQLException If an error occurs.
 827:    */
 828:   void updateByte(int columnIndex, byte x) throws SQLException;
 829: 
 830:   /**
 831:    * This method updates the specified column to have a short value.  This
 832:    * does not update the actual database.  <code>updateRow</code> must be
 833:    * called in order to do that.
 834:    *
 835:    * @param index The index of the column to update.
 836:    * @param value The new value of the column.
 837:    * @exception SQLException If an error occurs.
 838:    */
 839:   void updateShort(int columnIndex, short x) throws SQLException;
 840: 
 841:   /**
 842:    * This method updates the specified column to have an int value.  This
 843:    * does not update the actual database.  <code>updateRow</code> must be
 844:    * called in order to do that.
 845:    *
 846:    * @param index The index of the column to update.
 847:    * @param value The new value of the column.
 848:    * @exception SQLException If an error occurs.
 849:    */
 850:   void updateInt(int columnIndex, int x) throws SQLException;
 851: 
 852:   /**
 853:    * This method updates the specified column to have a long value.  This
 854:    * does not update the actual database.  <code>updateRow</code> must be
 855:    * called in order to do that.
 856:    *
 857:    * @param index The index of the column to update.
 858:    * @param value The new value of the column.
 859:    * @exception SQLException If an error occurs.
 860:    */
 861:   void updateLong(int columnIndex, long x) throws SQLException;
 862: 
 863:   /**
 864:    * This method updates the specified column to have a float value.  This
 865:    * does not update the actual database.  <code>updateRow</code> must be
 866:    * called in order to do that.
 867:    *
 868:    * @param index The index of the column to update.
 869:    * @param value The new value of the column.
 870:    * @exception SQLException If an error occurs.
 871:    */
 872:   void updateFloat(int columnIndex, float x) throws SQLException;
 873: 
 874:   /**
 875:    * This method updates the specified column to have a double value.  This
 876:    * does not update the actual database.  <code>updateRow</code> must be
 877:    * called in order to do that.
 878:    *
 879:    * @param index The index of the column to update.
 880:    * @param value The new value of the column.
 881:    * @exception SQLException If an error occurs.
 882:    */
 883:   void updateDouble(int columnIndex, double x) throws SQLException;
 884: 
 885:   /**
 886:    * This method updates the specified column to have a BigDecimal value.  This
 887:    * does not update the actual database.  <code>updateRow</code> must be
 888:    * called in order to do that.
 889:    *
 890:    * @param index The index of the column to update.
 891:    * @param value The new value of the column.
 892:    * @exception SQLException If an error occurs.
 893:    */
 894:   void updateBigDecimal(int columnIndex, BigDecimal x)
 895:     throws SQLException;
 896: 
 897:   /**
 898:    * This method updates the specified column to have a String value.  This
 899:    * does not update the actual database.  <code>updateRow</code> must be
 900:    * called in order to do that.
 901:    *
 902:    * @param index The index of the column to update.
 903:    * @param value The new value of the column.
 904:    * @exception SQLException If an error occurs.
 905:    */
 906:   void updateString(int columnIndex, String x) throws SQLException;
 907: 
 908:   /**
 909:    * This method updates the specified column to have a byte array value.  This
 910:    * does not update the actual database.  <code>updateRow</code> must be
 911:    * called in order to do that.
 912:    *
 913:    * @param index The index of the column to update.
 914:    * @param value The new value of the column.
 915:    * @exception SQLException If an error occurs.
 916:    */
 917:   void updateBytes(int columnIndex, byte[] x) throws SQLException;
 918: 
 919:   /**
 920:    * This method updates the specified column to have a java.sql.Date value.  This
 921:    * does not update the actual database.  <code>updateRow</code> must be
 922:    * called in order to do that.
 923:    *
 924:    * @param index The index of the column to update.
 925:    * @param value The new value of the column.
 926:    * @exception SQLException If an error occurs.
 927:    */
 928:   void updateDate(int columnIndex, Date x) throws SQLException;
 929: 
 930:   /**
 931:    * This method updates the specified column to have a java.sql.Time value.  This
 932:    * does not update the actual database.  <code>updateRow</code> must be
 933:    * called in order to do that.
 934:    *
 935:    * @param index The index of the column to update.
 936:    * @param value The new value of the column.
 937:    * @exception SQLException If an error occurs.
 938:    */
 939:   void updateTime(int columnIndex, Time x) throws SQLException;
 940: 
 941:   /**
 942:    * This method updates the specified column to have a java.sql.Timestamp value.  
 943:    * This does not update the actual database.  <code>updateRow</code> must be
 944:    * called in order to do that.
 945:    *
 946:    * @param index The index of the column to update.
 947:    * @param value The new value of the column.
 948:    * @exception SQLException If an error occurs.
 949:    */
 950:   void updateTimestamp(int columnIndex, Timestamp x)
 951:     throws SQLException;
 952: 
 953:   /**
 954:    * This method updates the specified column from an ASCII text stream.
 955:    * This does not update the actual database.  <code>updateRow</code> must be
 956:    * called in order to do that.
 957:    *
 958:    * @param index The index of the column to update.
 959:    * @param value The new value of the column.
 960:    * @param length The length of the stream.
 961:    * @exception SQLException If an error occurs.
 962:    */
 963:   void updateAsciiStream(int columnIndex, InputStream x, int length)
 964:     throws SQLException;
 965: 
 966:   /**
 967:    * This method updates the specified column from a binary stream.
 968:    * This does not update the actual database.  <code>updateRow</code> must be
 969:    * called in order to do that.
 970:    *
 971:    * @param index The index of the column to update.
 972:    * @param value The new value of the column.
 973:    * @param length The length of the stream.
 974:    * @exception SQLException If an error occurs.
 975:    */
 976:   void updateBinaryStream(int columnIndex, InputStream x, int length)
 977:     throws SQLException;
 978: 
 979:   /**
 980:    * This method updates the specified column from a character stream.
 981:    * This does not update the actual database.  <code>updateRow</code> must be
 982:    * called in order to do that.
 983:    *
 984:    * @param index The index of the column to update.
 985:    * @param value The new value of the column.
 986:    * @param length The length of the stream.
 987:    * @exception SQLException If an error occurs.
 988:    */
 989:   void updateCharacterStream(int columnIndex, Reader x, int length)
 990:     throws SQLException;
 991: 
 992:   /**
 993:    * This method updates the specified column to have an Object value.  
 994:    * This does not update the actual database.  <code>updateRow</code> must be
 995:    * called in order to do that.
 996:    *
 997:    * @param index The index of the column to update.
 998:    * @param value The new value of the column.
 999:    *
1000:    * @exception SQLException If an error occurs.
1001:    */
1002:   void updateObject(int columnIndex, Object x, int scale)
1003:     throws SQLException;
1004: 
1005:   /**
1006:    * This method updates the specified column to have an Object value.  
1007:    * This does not update the actual database.  <code>updateRow</code> must be
1008:    * called in order to do that.
1009:    *
1010:    * @param index The index of the column to update.
1011:    * @param value The new value of the column.
1012:    * @param scale The scale of the object in question, which is used only
1013:    *        for numeric type objects.
1014:    * @exception SQLException If an error occurs.
1015:    */
1016:   void updateObject(int columnIndex, Object x) throws SQLException;
1017: 
1018:   /**
1019:    * This method updates the specified column to have a NULL value.  This
1020:    * does not update the actual database.  <code>updateRow</code> must be
1021:    * called in order to do that.
1022:    *
1023:    * @return name The name of the column to update.
1024:    * @exception SQLException If an error occurs.
1025:    */
1026:   void updateNull(String columnName) throws SQLException;
1027: 
1028:   /**
1029:    * This method updates the specified column to have a boolean value.  This
1030:    * does not update the actual database.  <code>updateRow</code> must be
1031:    * called in order to do that.
1032:    *
1033:    * @param name The name of the column to update.
1034:    * @param value The new value of the column.
1035:    * @exception SQLException If an error occurs.
1036:    */
1037:   void updateBoolean(String columnName, boolean x) throws SQLException;
1038: 
1039:   /**
1040:    * This method updates the specified column to have a byte value.  This
1041:    * does not update the actual database.  <code>updateRow</code> must be
1042:    * called in order to do that.
1043:    *
1044:    * @param name The name of the column to update.
1045:    * @param value The new value of the column.
1046:    * @exception SQLException If an error occurs.
1047:    */
1048:   void updateByte(String columnName, byte x) throws SQLException;
1049: 
1050:   /**
1051:    * This method updates the specified column to have a short value.  This
1052:    * does not update the actual database.  <code>updateRow</code> must be
1053:    * called in order to do that.
1054:    *
1055:    * @param name The name of the column to update.
1056:    * @param value The new value of the column.
1057:    * @exception SQLException If an error occurs.
1058:    */
1059:   void updateShort(String columnName, short x) throws SQLException;
1060: 
1061:   /**
1062:    * This method updates the specified column to have an int value.  This
1063:    * does not update the actual database.  <code>updateRow</code> must be
1064:    * called in order to do that.
1065:    *
1066:    * @param name The name of the column to update.
1067:    * @param value The new value of the column.
1068:    * @exception SQLException If an error occurs.
1069:    */
1070:   void updateInt(String columnName, int x) throws SQLException;
1071: 
1072:   /**
1073:    * This method updates the specified column to have a long value.  This
1074:    * does not update the actual database.  <code>updateRow</code> must be
1075:    * called in order to do that.
1076:    *
1077:    * @param name The name of the column to update.
1078:    * @param value The new value of the column.
1079:    * @exception SQLException If an error occurs.
1080:    */
1081:   void updateLong(String columnName, long x) throws SQLException;
1082: 
1083:   /**
1084:    * This method updates the specified column to have a float value.  This
1085:    * does not update the actual database.  <code>updateRow</code> must be
1086:    * called in order to do that.
1087:    *
1088:    * @param name The name of the column to update.
1089:    * @param value The new value of the column.
1090:    * @exception SQLException If an error occurs.
1091:    */
1092:   void updateFloat(String columnName, float x) throws SQLException;
1093: 
1094:   /**
1095:    * This method updates the specified column to have a double value.  This
1096:    * does not update the actual database.  <code>updateRow</code> must be
1097:    * called in order to do that.
1098:    *
1099:    * @param name The name of the column to update.
1100:    * @param value The new value of the column.
1101:    * @exception SQLException If an error occurs.
1102:    */
1103:   void updateDouble(String columnName, double x) throws SQLException;
1104: 
1105:   /**
1106:    * This method updates the specified column to have a BigDecimal value.  This
1107:    * does not update the actual database.  <code>updateRow</code> must be
1108:    * called in order to do that.
1109:    *
1110:    * @param name The name of the column to update.
1111:    * @param value The new value of the column.
1112:    * @exception SQLException If an error occurs.
1113:    */
1114:   void updateBigDecimal(String columnName, BigDecimal x)
1115:     throws SQLException;
1116: 
1117:   /**
1118:    * This method updates the specified column to have a String value.  This
1119:    * does not update the actual database.  <code>updateRow</code> must be
1120:    * called in order to do that.
1121:    *
1122:    * @param name The name of the column to update.
1123:    * @param value The new value of the column.
1124:    * @exception SQLException If an error occurs.
1125:    */
1126:   void updateString(String columnName, String x) throws SQLException;
1127: 
1128:   /**
1129:    * This method updates the specified column to have a byte array value.  This
1130:    * does not update the actual database.  <code>updateRow</code> must be
1131:    * called in order to do that.
1132:    *
1133:    * @param name The name of the column to update.
1134:    * @param value The new value of the column.
1135:    * @exception SQLException If an error occurs.
1136:    */
1137:   void updateBytes(String columnName, byte[] x) throws SQLException;
1138: 
1139:   /**
1140:    * This method updates the specified column to have a java.sql.Date value.  This
1141:    * does not update the actual database.  <code>updateRow</code> must be
1142:    * called in order to do that.
1143:    *
1144:    * @param name The name of the column to update.
1145:    * @param value The new value of the column.
1146:    * @exception SQLException If an error occurs.
1147:    */
1148:   void updateDate(String columnName, Date x) throws SQLException;
1149: 
1150:   /**
1151:    * This method updates the specified column to have a java.sql.Time value.  This
1152:    * does not update the actual database.  <code>updateRow</code> must be
1153:    * called in order to do that.
1154:    *
1155:    * @param name The name of the column to update.
1156:    * @param value The new value of the column.
1157:    * @exception SQLException If an error occurs.
1158:    */
1159:   void updateTime(String columnName, Time x) throws SQLException;
1160: 
1161:   /**
1162:    * This method updates the specified column to have a java.sql.Timestamp value.  
1163:    * This does not update the actual database.  <code>updateRow</code> must be
1164:    * called in order to do that.
1165:    *
1166:    * @param name The name of the column to update.
1167:    * @param value The new value of the column.
1168:    * @exception SQLException If an error occurs.
1169:    */
1170:   void updateTimestamp(String columnName, Timestamp x)
1171:     throws SQLException;
1172: 
1173:   /**
1174:    * This method updates the specified column from an ASCII text stream.
1175:    * This does not update the actual database.  <code>updateRow</code> must be
1176:    * called in order to do that.
1177:    *
1178:    * @param name The name of the column to update.
1179:    * @param value The new value of the column.
1180:    * @param length The length of the stream.
1181:    * @exception SQLException If an error occurs.
1182:    */
1183:   void updateAsciiStream(String columnName, InputStream x, int length)
1184:     throws SQLException;
1185: 
1186:   /**
1187:    * This method updates the specified column from a binary stream.
1188:    * This does not update the actual database.  <code>updateRow</code> must be
1189:    * called in order to do that.
1190:    *
1191:    * @param name The name of the column to update.
1192:    * @param value The new value of the column.
1193:    * @param length The length of the stream.
1194:    * @exception SQLException If an error occurs.
1195:    */
1196:   void updateBinaryStream(String columnName, InputStream x, int length)
1197:     throws SQLException;
1198: 
1199:   /**
1200:    * This method updates the specified column from a character stream.
1201:    * This does not update the actual database.  <code>updateRow</code> must be
1202:    * called in order to do that.
1203:    *
1204:    * @param name The name of the column to update.
1205:    * @param value The new value of the column.
1206:    * @param length The length of the stream.
1207:    *
1208:    * @exception SQLException If an error occurs.
1209:    */
1210:   void updateCharacterStream(String columnName, Reader reader,
1211:     int length) throws SQLException;
1212: 
1213:   /**
1214:    * This method updates the specified column to have an Object value.  
1215:    * This does not update the actual database.  <code>updateRow</code> must be
1216:    * called in order to do that.
1217:    *
1218:    * @param name The name of the column to update.
1219:    * @param value The new value of the column.
1220:    * @exception SQLException If an error occurs.
1221:    */
1222:   void updateObject(String columnName, Object x, int scale)
1223:     throws SQLException;
1224: 
1225:   /**
1226:    * This method updates the specified column to have an Object value.  
1227:    * This does not update the actual database.  <code>updateRow</code> must be
1228:    * called in order to do that.
1229:    *
1230:    * @param name The name of the column to update.
1231:    * @param value The new value of the column.
1232:    * @param scale The scale of the object in question, which is used only
1233:    *        for numeric type objects.
1234:    * @exception SQLException If an error occurs.
1235:    */
1236:   void updateObject(String columnName, Object x) throws SQLException;
1237: 
1238:   /**
1239:    * This method inserts the current row into the database.  The result set
1240:    * must be positioned on the insert row in order to call this method
1241:    * successfully.
1242:    *
1243:    * @exception SQLException If an error occurs.
1244:    */
1245:   void insertRow() throws SQLException;
1246: 
1247:   /**
1248:    * This method updates the current row in the database.
1249:    *
1250:    * @exception SQLException If an error occurs.
1251:    */
1252:   void updateRow() throws SQLException;
1253: 
1254:   /**
1255:    * This method deletes the current row in the database.
1256:    *
1257:    * @exception SQLException If an error occurs.
1258:    */
1259:   void deleteRow() throws SQLException;
1260: 
1261:   /**
1262:    * This method refreshes the contents of the current row from the database.
1263:    *
1264:    * @exception SQLException If an error occurs.
1265:    */
1266:   void refreshRow() throws SQLException;
1267: 
1268:   /**
1269:    * This method cancels any changes that have been made to a row.  If 
1270:    * the <code>rowUpdate</code> method has been called, then the changes
1271:    * cannot be undone.
1272:    *
1273:    * @exception SQLException If an error occurs.
1274:    */
1275:   void cancelRowUpdates() throws SQLException;
1276: 
1277:   /**
1278:    * This method positions the result set to the "insert row", which allows
1279:    * a new row to be inserted into the database from the result set.
1280:    *
1281:    * @exception SQLException If an error occurs.
1282:    */
1283:   void moveToInsertRow() throws SQLException;
1284: 
1285:   /**
1286:    * This method moves the result set position from the insert row back to
1287:    * the current row that was selected prior to moving to the insert row.
1288:    *
1289:    * @exception SQLException If an error occurs.
1290:    */
1291:   void moveToCurrentRow() throws SQLException;
1292: 
1293:   /**
1294:    * This method returns a the <code>Statement</code> that was used to
1295:    * produce this result set.
1296:    *
1297:    * @return The <code>Statement</code> used to produce this result set.
1298:    *
1299:    * @exception SQLException If an error occurs.
1300:    */
1301:   Statement getStatement() throws SQLException;
1302: 
1303:   /**
1304:    * This method returns the value of the specified column as a Java
1305:    * <code>Object</code> using the specified SQL type to Java type map.
1306:    *
1307:    * @param index The index of the column to return.
1308:    * @param map The SQL type to Java type map to use.
1309:    * @return The value of the column as an <code>Object</code>.
1310:    * @exception SQLException If an error occurs.
1311:    */
1312:   Object getObject(int i, Map map) throws SQLException;
1313: 
1314:   /**
1315:    * This method returns a <code>Ref</code> for the specified column which
1316:    * represents the structured type for the column.
1317:    *
1318:    * @param index  The index of the column to return.
1319:    * @return A <code>Ref</code> object for the column
1320:    * @exception SQLException If an error occurs.
1321:    */
1322:   Ref getRef(int i) throws SQLException;
1323: 
1324:   /**
1325:    * This method returns the specified column value as a BLOB.
1326:    *
1327:    * @param index The index of the column value to return.
1328:    * @return The value of the column as a BLOB.
1329:    * @exception SQLException If an error occurs.
1330:    */
1331:   Blob getBlob(int i) throws SQLException;
1332: 
1333:   /**
1334:    * This method returns the specified column value as a CLOB.
1335:    *
1336:    * @param index The index of the column value to return.
1337:    * @return The value of the column as a CLOB.
1338:    * @exception SQLException If an error occurs.
1339:    */
1340:   Clob getClob(int i) throws SQLException;
1341: 
1342:   /**
1343:    * This method returns the specified column value as an <code>Array</code>.
1344:    *
1345:    * @param index The index of the column value to return.
1346:    * @return The value of the column as an <code>Array</code>.
1347:    * @exception SQLException If an error occurs.
1348:    */
1349:   Array getArray(int i) throws SQLException;
1350: 
1351:   /**
1352:    * This method returns the value of the specified column as a Java
1353:    * <code>Object</code> using the specified SQL type to Java type map.
1354:    *
1355:    * @param name The name of the column to return.
1356:    * @param map The SQL type to Java type map to use.
1357:    * @return The value of the column as an <code>Object</code>.
1358:    * @exception SQLException If an error occurs.
1359:    */
1360:   Object getObject(String colName, Map map) throws SQLException;
1361: 
1362:   /**
1363:    * This method returns a <code>Ref</code> for the specified column which
1364:    * represents the structured type for the column.
1365:    *
1366:    * @param index  The index of the column to return.
1367:    * @return A <code>Ref</code> object for the column
1368:    * @exception SQLException If an error occurs.
1369:    */
1370:   Ref getRef(String colName) throws SQLException;
1371: 
1372:   /**
1373:    * This method returns the specified column value as a BLOB.
1374:    *
1375:    * @param name The name of the column value to return.
1376:    * @return The value of the column as a BLOB.
1377:    * @exception SQLException If an error occurs.
1378:    */
1379:   Blob getBlob(String colName) throws SQLException;
1380: 
1381:   /**
1382:    * This method returns the specified column value as a CLOB.
1383:    *
1384:    * @param name The name of the column value to return.
1385:    * @return The value of the column as a CLOB.
1386:    * @exception SQLException If an error occurs.
1387:    */
1388:   Clob getClob(String colName) throws SQLException;
1389: 
1390:   /**
1391:    * This method returns the specified column value as an <code>Array</code>.
1392:    *
1393:    * @param name The name of the column value to return.
1394:    * @return The value of the column as an <code>Array</code>.
1395:    * @exception SQLException If an error occurs.
1396:    */
1397:   Array getArray(String colName) throws SQLException;
1398: 
1399:   /**
1400:    * This method returns the specified column value as a 
1401:    * <code>java.sql.Date</code>.  The specified <code>Calendar</code> is used
1402:    * to generate a value for the date if the database does not support
1403:    * timezones.
1404:    *
1405:    * @param index The index of the column value to return.
1406:    * @param cal The <code>Calendar</code> to use for calculating timezones.
1407:    * @return The value of the column as a <code>java.sql.Date</code>.
1408:    * @exception SQLException If an error occurs.
1409:    */
1410:   Date getDate(int columnIndex, Calendar cal) throws SQLException;
1411: 
1412:   /**
1413:    * This method returns the specified column value as a 
1414:    * <code>java.sql.Date</code>.  The specified <code>Calendar</code> is used
1415:    * to generate a value for the date if the database does not support
1416:    * timezones.
1417:    *
1418:    * @param name The name of the column value to return.
1419:    * @param cal The <code>Calendar</code> to use for calculating timezones.
1420:    * @return The value of the column as a <code>java.sql.Date</code>.
1421:    * @exception SQLException If an error occurs.
1422:    */
1423:   Date getDate(String columnName, Calendar cal) throws SQLException;
1424: 
1425:   /**
1426:    * This method returns the specified column value as a 
1427:    * <code>java.sql.Time</code>.  The specified <code>Calendar</code> is used
1428:    * to generate a value for the time if the database does not support
1429:    * timezones.
1430:    *
1431:    * @param index The index of the column value to return.
1432:    * @param cal The <code>Calendar</code> to use for calculating timezones.
1433:    * @return The value of the column as a <code>java.sql.Time</code>.
1434:    * @exception SQLException If an error occurs.
1435:    */
1436:   Time getTime(int columnIndex, Calendar cal) throws SQLException;
1437: 
1438:   /**
1439:    * This method returns the specified column value as a 
1440:    * <code>java.sql.Time</code>.  The specified <code>Calendar</code> is used
1441:    * to generate a value for the time if the database does not support
1442:    * timezones.
1443:    *
1444:    * @param name The name of the column value to return.
1445:    * @param cal The <code>Calendar</code> to use for calculating timezones.
1446:    * @return The value of the column as a <code>java.sql.Time</code>.
1447:    * @exception SQLException If an error occurs.
1448:    */
1449:   Time getTime(String columnName, Calendar cal) throws SQLException;
1450: 
1451:   /**
1452:    * This method returns the specified column value as a 
1453:    * <code>java.sql.Timestamp</code>.  The specified <code>Calendar</code> is used
1454:    * to generate a value for the timestamp if the database does not support
1455:    * timezones.
1456:    *
1457:    * @param index The index of the column value to return.
1458:    * @param cal The <code>Calendar</code> to use for calculating timezones.
1459:    * @return The value of the column as a <code>java.sql.Timestamp</code>.
1460:    * @exception SQLException If an error occurs.
1461:    */
1462:   Timestamp getTimestamp(int columnIndex, Calendar cal)
1463:     throws SQLException;
1464: 
1465:   /**
1466:    * This method returns the specified column value as a 
1467:    * <code>java.sql.Timestamp</code>.  The specified <code>Calendar</code> is used
1468:    * to generate a value for the timestamp if the database does not support
1469:    * timezones.
1470:    *
1471:    * @param name The name of the column value to return.
1472:    * @param cal The <code>Calendar</code> to use for calculating timezones.
1473:    *
1474:    * @return The value of the column as a <code>java.sql.Timestamp</code>.
1475:    *
1476:    * @exception SQLException If an error occurs.
1477:    */
1478:   Timestamp getTimestamp(String columnName, Calendar cal)
1479:     throws SQLException;
1480: 
1481:   /**
1482:    * @since 1.4
1483:    */
1484:   URL getURL(int columnIndex) throws SQLException;
1485: 
1486:   /**
1487:    * @since 1.4
1488:    */
1489:   URL getURL(String columnName) throws SQLException;
1490: 
1491:   /**
1492:    * @since 1.4
1493:    */
1494:   void updateRef(int columnIndex, Ref x) throws SQLException;
1495: 
1496:   /**
1497:    * @since 1.4
1498:    */
1499:   void updateRef(String columnName, Ref x) throws SQLException;
1500: 
1501:   /**
1502:    * @since 1.4
1503:    */
1504:   void updateBlob(int columnIndex, Blob x) throws SQLException;
1505: 
1506:   /**
1507:    * @since 1.4
1508:    */
1509:   void updateBlob(String columnName, Blob x) throws SQLException;
1510: 
1511:   /**
1512:    * @since 1.4
1513:    */
1514:   void updateClob(int columnIndex, Clob x) throws SQLException;
1515: 
1516:   /**
1517:    * @since 1.4
1518:    */
1519:   void updateClob(String columnName, Clob x) throws SQLException;
1520: 
1521:   /**
1522:    * @since 1.4
1523:    */
1524:   void updateArray(int columnIndex, Array x) throws SQLException;
1525: 
1526:   /**
1527:    * @since 1.4
1528:    */
1529:   void updateArray(String columnName, Array x) throws SQLException;
1530: }