1package SQLite.JDBC2y; 2 3import java.sql.*; 4import java.math.BigDecimal; 5 6public class JDBCResultSet implements java.sql.ResultSet { 7 8 /** 9 * Current row to be retrieved. 10 */ 11 private int row; 12 13 /** 14 * Table returned by Database.get_table() 15 */ 16 protected SQLite.TableResult tr; 17 18 /** 19 * Statement from which result set was produced. 20 */ 21 private JDBCStatement s; 22 23 /** 24 * Meta data for result set or null. 25 */ 26 private JDBCResultSetMetaData m; 27 28 /** 29 * Last result cell retrieved or null. 30 */ 31 private String lastg; 32 33 34 public JDBCResultSet(SQLite.TableResult tr, JDBCStatement s) { 35 this.tr = tr; 36 this.s = s; 37 this.m = null; 38 this.lastg = null; 39 this.row = -1; 40 } 41 42 public boolean next() throws SQLException { 43 if (tr == null) { 44 return false; 45 } 46 row++; 47 return row < tr.nrows; 48 } 49 50 public int findColumn(String columnName) throws SQLException { 51 JDBCResultSetMetaData m = (JDBCResultSetMetaData) getMetaData(); 52 return m.findColByName(columnName); 53 } 54 55 public int getRow() throws SQLException { 56 if (tr == null) { 57 throw new SQLException("no rows"); 58 } 59 return row + 1; 60 } 61 62 public boolean previous() throws SQLException { 63 if (tr == null) { 64 return false; 65 } 66 if (row >= 0) { 67 row--; 68 } 69 return row >= 0; 70 } 71 72 public boolean absolute(int row) throws SQLException { 73 if (tr == null) { 74 return false; 75 } 76 if (row < 0) { 77 row = tr.nrows + 1 + row; 78 } 79 row--; 80 if (row < 0 || row > tr.nrows) { 81 return false; 82 } 83 this.row = row; 84 return true; 85 } 86 87 public boolean relative(int row) throws SQLException { 88 if (tr == null) { 89 return false; 90 } 91 if (this.row + row < 0 || this.row + row >= tr.nrows) { 92 return false; 93 } 94 this.row += row; 95 return true; 96 } 97 98 public void setFetchDirection(int dir) throws SQLException { 99 throw new SQLException("not supported"); 100 } 101 102 public int getFetchDirection() throws SQLException { 103 throw new SQLException("not supported"); 104 } 105 106 public void setFetchSize(int fsize) throws SQLException { 107 throw new SQLException("not supported"); 108 } 109 110 public int getFetchSize() throws SQLException { 111 throw new SQLException("not supported"); 112 } 113 114 public String getString(int columnIndex) throws SQLException { 115 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 116 throw new SQLException("column " + columnIndex + " not found"); 117 } 118 String rd[] = (String []) tr.rows.elementAt(row); 119 lastg = rd[columnIndex - 1]; 120 return lastg; 121 } 122 123 public String getString(String columnName) throws SQLException { 124 int col = findColumn(columnName); 125 return getString(col); 126 } 127 128 public int getInt(int columnIndex) throws SQLException { 129 Integer i = internalGetInt(columnIndex); 130 if (i != null) { 131 return i.intValue(); 132 } 133 return 0; 134 } 135 136 private Integer internalGetInt(int columnIndex) throws SQLException { 137 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 138 throw new SQLException("column " + columnIndex + " not found"); 139 } 140 String rd[] = (String []) tr.rows.elementAt(row); 141 lastg = rd[columnIndex - 1]; 142 try { 143 return Integer.valueOf(lastg); 144 } catch (java.lang.Exception e) { 145 lastg = null; 146 } 147 return null; 148 } 149 150 public int getInt(String columnName) throws SQLException { 151 int col = findColumn(columnName); 152 return getInt(col); 153 } 154 155 public boolean getBoolean(int columnIndex) throws SQLException { 156 throw new SQLException("not supported"); 157 } 158 159 public boolean getBoolean(String columnName) throws SQLException { 160 throw new SQLException("not supported"); 161 } 162 163 public ResultSetMetaData getMetaData() throws SQLException { 164 if (m == null) { 165 m = new JDBCResultSetMetaData(this); 166 } 167 return m; 168 } 169 170 public short getShort(int columnIndex) throws SQLException { 171 Short s = internalGetShort(columnIndex); 172 if (s != null) { 173 return s.shortValue(); 174 } 175 return 0; 176 } 177 178 private Short internalGetShort(int columnIndex) throws SQLException { 179 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 180 throw new SQLException("column " + columnIndex + " not found"); 181 } 182 String rd[] = (String []) tr.rows.elementAt(row); 183 lastg = rd[columnIndex - 1]; 184 try { 185 return Short.valueOf(lastg); 186 } catch (java.lang.Exception e) { 187 lastg = null; 188 } 189 return null; 190 } 191 192 public short getShort(String columnName) throws SQLException { 193 int col = findColumn(columnName); 194 return getShort(col); 195 } 196 197 public java.sql.Time getTime(int columnIndex) throws SQLException { 198 return internalGetTime(columnIndex, null); 199 } 200 201 private java.sql.Time internalGetTime(int columnIndex, 202 java.util.Calendar cal) 203 throws SQLException { 204 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 205 throw new SQLException("column " + columnIndex + " not found"); 206 } 207 String rd[] = (String []) tr.rows.elementAt(row); 208 lastg = rd[columnIndex - 1]; 209 try { 210 return java.sql.Time.valueOf(lastg); 211 } catch (java.lang.Exception e) { 212 lastg = null; 213 } 214 return null; 215 } 216 217 public java.sql.Time getTime(String columnName) throws SQLException { 218 int col = findColumn(columnName); 219 return getTime(col); 220 } 221 222 public java.sql.Time getTime(int columnIndex, java.util.Calendar cal) 223 throws SQLException { 224 return internalGetTime(columnIndex, cal); 225 } 226 227 public java.sql.Time getTime(String columnName, java.util.Calendar cal) 228 throws SQLException{ 229 int col = findColumn(columnName); 230 return getTime(col, cal); 231 } 232 233 public java.sql.Timestamp getTimestamp(int columnIndex) 234 throws SQLException{ 235 return internalGetTimestamp(columnIndex, null); 236 } 237 238 private java.sql.Timestamp internalGetTimestamp(int columnIndex, 239 java.util.Calendar cal) 240 throws SQLException { 241 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 242 throw new SQLException("column " + columnIndex + " not found"); 243 } 244 String rd[] = (String []) tr.rows.elementAt(row); 245 lastg = rd[columnIndex - 1]; 246 try { 247 return java.sql.Timestamp.valueOf(lastg); 248 } catch (java.lang.Exception e) { 249 lastg = null; 250 } 251 return null; 252 } 253 254 public java.sql.Timestamp getTimestamp(String columnName) 255 throws SQLException{ 256 int col = findColumn(columnName); 257 return getTimestamp(col); 258 } 259 260 public java.sql.Timestamp getTimestamp(int columnIndex, 261 java.util.Calendar cal) 262 throws SQLException { 263 return internalGetTimestamp(columnIndex, cal); 264 } 265 266 public java.sql.Timestamp getTimestamp(String columnName, 267 java.util.Calendar cal) 268 throws SQLException { 269 int col = findColumn(columnName); 270 return getTimestamp(col, cal); 271 } 272 273 public java.sql.Date getDate(int columnIndex) throws SQLException { 274 return internalGetDate(columnIndex, null); 275 } 276 277 private java.sql.Date internalGetDate(int columnIndex, 278 java.util.Calendar cal) 279 throws SQLException { 280 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 281 throw new SQLException("column " + columnIndex + " not found"); 282 } 283 String rd[] = (String []) tr.rows.elementAt(row); 284 lastg = rd[columnIndex - 1]; 285 try { 286 return java.sql.Date.valueOf(lastg); 287 } catch (java.lang.Exception e) { 288 lastg = null; 289 } 290 return null; 291 } 292 293 public java.sql.Date getDate(String columnName) throws SQLException { 294 int col = findColumn(columnName); 295 return getDate(col); 296 } 297 298 public java.sql.Date getDate(int columnIndex, java.util.Calendar cal) 299 throws SQLException{ 300 return internalGetDate(columnIndex, cal); 301 } 302 303 public java.sql.Date getDate(String columnName, java.util.Calendar cal) 304 throws SQLException{ 305 int col = findColumn(columnName); 306 return getDate(col, cal); 307 } 308 309 public double getDouble(int columnIndex) throws SQLException { 310 Double d = internalGetDouble(columnIndex); 311 if (d != null) { 312 return d.doubleValue(); 313 } 314 return 0; 315 } 316 317 private Double internalGetDouble(int columnIndex) throws SQLException { 318 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 319 throw new SQLException("column " + columnIndex + " not found"); 320 } 321 String rd[] = (String []) tr.rows.elementAt(row); 322 lastg = rd[columnIndex - 1]; 323 try { 324 return Double.valueOf(lastg); 325 } catch (java.lang.Exception e) { 326 lastg = null; 327 } 328 return null; 329 } 330 331 public double getDouble(String columnName) throws SQLException { 332 int col = findColumn(columnName); 333 return getDouble(col); 334 } 335 336 public float getFloat(int columnIndex) throws SQLException { 337 Float f = internalGetFloat(columnIndex); 338 if (f != null) { 339 return f.floatValue(); 340 } 341 return 0; 342 } 343 344 private Float internalGetFloat(int columnIndex) throws SQLException { 345 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 346 throw new SQLException("column " + columnIndex + " not found"); 347 } 348 String rd[] = (String []) tr.rows.elementAt(row); 349 lastg = rd[columnIndex - 1]; 350 try { 351 return Float.valueOf(lastg); 352 } catch (java.lang.Exception e) { 353 lastg = null; 354 } 355 return null; 356 } 357 358 public float getFloat(String columnName) throws SQLException { 359 int col = findColumn(columnName); 360 return getFloat(col); 361 } 362 363 public long getLong(int columnIndex) throws SQLException { 364 Long l = internalGetLong(columnIndex); 365 if (l != null) { 366 return l.longValue(); 367 } 368 return 0; 369 } 370 371 private Long internalGetLong(int columnIndex) throws SQLException { 372 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 373 throw new SQLException("column " + columnIndex + " not found"); 374 } 375 String rd[] = (String []) tr.rows.elementAt(row); 376 lastg = rd[columnIndex - 1]; 377 try { 378 return Long.valueOf(lastg); 379 } catch (java.lang.Exception e) { 380 lastg = null; 381 } 382 return null; 383 } 384 385 public long getLong(String columnName) throws SQLException { 386 int col = findColumn(columnName); 387 return getLong(col); 388 } 389 390 @Deprecated 391 public java.io.InputStream getUnicodeStream(int columnIndex) 392 throws SQLException { 393 throw new SQLException("not supported"); 394 } 395 396 @Deprecated 397 public java.io.InputStream getUnicodeStream(String columnName) 398 throws SQLException { 399 throw new SQLException("not supported"); 400 } 401 402 public java.io.InputStream getAsciiStream(String columnName) 403 throws SQLException { 404 throw new SQLException("not supported"); 405 } 406 407 public java.io.InputStream getAsciiStream(int columnIndex) 408 throws SQLException { 409 throw new SQLException("not supported"); 410 } 411 412 public BigDecimal getBigDecimal(String columnName) 413 throws SQLException { 414 throw new SQLException("not supported"); 415 } 416 417 @Deprecated 418 public BigDecimal getBigDecimal(String columnName, int scale) 419 throws SQLException { 420 throw new SQLException("not supported"); 421 } 422 423 public BigDecimal getBigDecimal(int columnIndex) throws SQLException { 424 throw new SQLException("not supported"); 425 } 426 427 @Deprecated 428 public BigDecimal getBigDecimal(int columnIndex, int scale) 429 throws SQLException { 430 throw new SQLException("not supported"); 431 } 432 433 public java.io.InputStream getBinaryStream(int columnIndex) 434 throws SQLException { 435 throw new SQLException("not supported"); 436 } 437 438 public java.io.InputStream getBinaryStream(String columnName) 439 throws SQLException { 440 throw new SQLException("not supported"); 441 } 442 443 public byte getByte(int columnIndex) throws SQLException { 444 throw new SQLException("not supported"); 445 } 446 447 public byte getByte(String columnName) throws SQLException { 448 throw new SQLException("not supported"); 449 } 450 451 public byte[] getBytes(int columnIndex) throws SQLException { 452 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 453 throw new SQLException("column " + columnIndex + " not found"); 454 } 455 byte ret[] = null; 456 String rd[] = (String []) tr.rows.elementAt(row); 457 lastg = rd[columnIndex - 1]; 458 if (lastg != null) { 459 ret = SQLite.StringEncoder.decode(lastg); 460 } 461 return ret; 462 } 463 464 public byte[] getBytes(String columnName) throws SQLException { 465 int col = findColumn(columnName); 466 return getBytes(col); 467 } 468 469 public String getCursorName() throws SQLException { 470 return null; 471 } 472 473 public Object getObject(int columnIndex) throws SQLException { 474 if (tr == null || columnIndex < 1 || columnIndex > tr.ncolumns) { 475 throw new SQLException("column " + columnIndex + " not found"); 476 } 477 String rd[] = (String []) tr.rows.elementAt(row); 478 lastg = rd[columnIndex - 1]; 479 Object ret = lastg; 480 if (tr instanceof TableResultX) { 481 switch (((TableResultX) tr).sql_type[columnIndex - 1]) { 482 case Types.SMALLINT: 483 ret = internalGetShort(columnIndex); 484 break; 485 case Types.INTEGER: 486 ret = internalGetInt(columnIndex); 487 break; 488 case Types.DOUBLE: 489 ret = internalGetDouble(columnIndex); 490 break; 491 case Types.FLOAT: 492 ret = internalGetFloat(columnIndex); 493 break; 494 case Types.BIGINT: 495 ret = internalGetLong(columnIndex); 496 break; 497 case Types.BINARY: 498 case Types.VARBINARY: 499 case Types.LONGVARBINARY: 500 ret = getBytes(columnIndex); 501 break; 502 case Types.NULL: 503 ret = null; 504 break; 505 /* defaults to String below */ 506 } 507 } 508 return ret; 509 } 510 511 public Object getObject(String columnName) throws SQLException { 512 int col = findColumn(columnName); 513 return getObject(col); 514 } 515 516 public Object getObject(int columnIndex, java.util.Map map) 517 throws SQLException { 518 throw new SQLException("not supported"); 519 } 520 521 public Object getObject(String columnIndex, java.util.Map map) 522 throws SQLException { 523 throw new SQLException("not supported"); 524 } 525 526 public java.sql.Ref getRef(int columnIndex) throws SQLException { 527 throw new SQLException("not supported"); 528 } 529 530 public java.sql.Ref getRef(String columnIndex) throws SQLException { 531 throw new SQLException("not supported"); 532 } 533 534 public java.sql.Blob getBlob(int columnIndex) throws SQLException { 535 throw new SQLException("not supported"); 536 } 537 538 public java.sql.Blob getBlob(String columnIndex) throws SQLException { 539 throw new SQLException("not supported"); 540 } 541 542 public java.sql.Clob getClob(int columnIndex) throws SQLException { 543 throw new SQLException("not supported"); 544 } 545 546 public java.sql.Clob getClob(String columnIndex) throws SQLException { 547 throw new SQLException("not supported"); 548 } 549 550 public java.sql.Array getArray(int columnIndex) throws SQLException { 551 throw new SQLException("not supported"); 552 } 553 554 public java.sql.Array getArray(String columnIndex) throws SQLException { 555 throw new SQLException("not supported"); 556 } 557 558 public java.io.Reader getCharacterStream(int columnIndex) 559 throws SQLException { 560 throw new SQLException("not supported"); 561 } 562 563 public java.io.Reader getCharacterStream(String columnName) 564 throws SQLException { 565 throw new SQLException("not supported"); 566 } 567 568 public SQLWarning getWarnings() throws SQLException { 569 throw new SQLException("not supported"); 570 } 571 572 public boolean wasNull() throws SQLException { 573 return lastg == null; 574 } 575 576 public void clearWarnings() throws SQLException { 577 throw new SQLException("not supported"); 578 } 579 580 public boolean isFirst() throws SQLException { 581 if (tr == null) { 582 return true; 583 } 584 return row == 0; 585 } 586 587 public boolean isBeforeFirst() throws SQLException { 588 if (tr == null || tr.nrows <= 0) { 589 return false; 590 } 591 return row < 0; 592 } 593 594 public void beforeFirst() throws SQLException { 595 if (tr == null) { 596 return; 597 } 598 row = -1; 599 } 600 601 public boolean first() throws SQLException { 602 if (tr == null || tr.nrows <= 0) { 603 return false; 604 } 605 row = 0; 606 return true; 607 } 608 609 public boolean isAfterLast() throws SQLException { 610 if (tr == null || tr.nrows <= 0) { 611 return false; 612 } 613 return row >= tr.nrows; 614 } 615 616 public void afterLast() throws SQLException { 617 if (tr == null) { 618 return; 619 } 620 row = tr.nrows; 621 } 622 623 public boolean isLast() throws SQLException { 624 if (tr == null) { 625 return true; 626 } 627 return row == tr.nrows - 1; 628 } 629 630 public boolean last() throws SQLException { 631 if (tr == null || tr.nrows <= 0) { 632 return false; 633 } 634 row = tr.nrows -1; 635 return true; 636 } 637 638 public int getType() throws SQLException { 639 return TYPE_SCROLL_INSENSITIVE; 640 } 641 642 public int getConcurrency() throws SQLException { 643 return CONCUR_READ_ONLY; 644 } 645 646 public boolean rowUpdated() throws SQLException { 647 throw new SQLException("not supported"); 648 } 649 650 public boolean rowInserted() throws SQLException { 651 throw new SQLException("not supported"); 652 } 653 654 public boolean rowDeleted() throws SQLException { 655 throw new SQLException("not supported"); 656 } 657 658 public void insertRow() throws SQLException { 659 throw new SQLException("not supported"); 660 } 661 662 public void updateRow() throws SQLException { 663 throw new SQLException("not supported"); 664 } 665 666 public void deleteRow() throws SQLException { 667 throw new SQLException("not supported"); 668 } 669 670 public void refreshRow() throws SQLException { 671 throw new SQLException("not supported"); 672 } 673 674 public void cancelRowUpdates() throws SQLException { 675 throw new SQLException("not supported"); 676 } 677 678 public void moveToInsertRow() throws SQLException { 679 throw new SQLException("not supported"); 680 } 681 682 public void moveToCurrentRow() throws SQLException { 683 throw new SQLException("not supported"); 684 } 685 686 public void updateNull(int colIndex) throws SQLException { 687 throw new SQLException("not supported"); 688 } 689 690 public void updateBoolean(int colIndex, boolean b) throws SQLException { 691 throw new SQLException("not supported"); 692 } 693 694 public void updateByte(int colIndex, byte b) throws SQLException { 695 throw new SQLException("not supported"); 696 } 697 698 public void updateShort(int colIndex, short b) throws SQLException { 699 throw new SQLException("not supported"); 700 } 701 702 public void updateInt(int colIndex, int b) throws SQLException { 703 throw new SQLException("not supported"); 704 } 705 706 public void updateLong(int colIndex, long b) throws SQLException { 707 throw new SQLException("not supported"); 708 } 709 710 public void updateFloat(int colIndex, float f) throws SQLException { 711 throw new SQLException("not supported"); 712 } 713 714 public void updateDouble(int colIndex, double f) throws SQLException { 715 throw new SQLException("not supported"); 716 } 717 718 public void updateBigDecimal(int colIndex, BigDecimal f) 719 throws SQLException { 720 throw new SQLException("not supported"); 721 } 722 723 public void updateString(int colIndex, String s) throws SQLException { 724 throw new SQLException("not supported"); 725 } 726 727 public void updateBytes(int colIndex, byte[] s) throws SQLException { 728 throw new SQLException("not supported"); 729 } 730 731 public void updateDate(int colIndex, java.sql.Date d) throws SQLException { 732 throw new SQLException("not supported"); 733 } 734 735 public void updateTime(int colIndex, java.sql.Time t) throws SQLException { 736 throw new SQLException("not supported"); 737 } 738 739 public void updateTimestamp(int colIndex, java.sql.Timestamp t) 740 throws SQLException { 741 throw new SQLException("not supported"); 742 } 743 744 public void updateAsciiStream(int colIndex, java.io.InputStream in, int s) 745 throws SQLException { 746 throw new SQLException("not supported"); 747 } 748 749 public void updateBinaryStream(int colIndex, java.io.InputStream in, int s) 750 throws SQLException { 751 throw new SQLException("not supported"); 752 } 753 754 public void updateCharacterStream(int colIndex, java.io.Reader in, int s) 755 throws SQLException { 756 throw new SQLException("not supported"); 757 } 758 759 public void updateObject(int colIndex, Object obj) throws SQLException { 760 throw new SQLException("not supported"); 761 } 762 763 public void updateObject(int colIndex, Object obj, int s) 764 throws SQLException { 765 throw new SQLException("not supported"); 766 } 767 768 public void updateNull(String colIndex) throws SQLException { 769 throw new SQLException("not supported"); 770 } 771 772 public void updateBoolean(String colIndex, boolean b) throws SQLException { 773 throw new SQLException("not supported"); 774 } 775 776 public void updateByte(String colIndex, byte b) throws SQLException { 777 throw new SQLException("not supported"); 778 } 779 780 public void updateShort(String colIndex, short b) throws SQLException { 781 throw new SQLException("not supported"); 782 } 783 784 public void updateInt(String colIndex, int b) throws SQLException { 785 throw new SQLException("not supported"); 786 } 787 788 public void updateLong(String colIndex, long b) throws SQLException { 789 throw new SQLException("not supported"); 790 } 791 792 public void updateFloat(String colIndex, float f) throws SQLException { 793 throw new SQLException("not supported"); 794 } 795 796 public void updateDouble(String colIndex, double f) throws SQLException { 797 throw new SQLException("not supported"); 798 } 799 800 public void updateBigDecimal(String colIndex, BigDecimal f) 801 throws SQLException { 802 throw new SQLException("not supported"); 803 } 804 805 public void updateString(String colIndex, String s) throws SQLException { 806 throw new SQLException("not supported"); 807 } 808 809 public void updateBytes(String colIndex, byte[] s) throws SQLException { 810 throw new SQLException("not supported"); 811 } 812 813 public void updateDate(String colIndex, java.sql.Date d) 814 throws SQLException { 815 throw new SQLException("not supported"); 816 } 817 818 public void updateTime(String colIndex, java.sql.Time t) 819 throws SQLException { 820 throw new SQLException("not supported"); 821 } 822 823 public void updateTimestamp(String colIndex, java.sql.Timestamp t) 824 throws SQLException { 825 throw new SQLException("not supported"); 826 } 827 828 public void updateAsciiStream(String colIndex, java.io.InputStream in, 829 int s) 830 throws SQLException { 831 throw new SQLException("not supported"); 832 } 833 834 public void updateBinaryStream(String colIndex, java.io.InputStream in, 835 int s) 836 throws SQLException { 837 throw new SQLException("not supported"); 838 } 839 840 public void updateCharacterStream(String colIndex, java.io.Reader in, 841 int s) 842 throws SQLException { 843 throw new SQLException("not supported"); 844 } 845 846 public void updateObject(String colIndex, Object obj) 847 throws SQLException { 848 throw new SQLException("not supported"); 849 } 850 851 public void updateObject(String colIndex, Object obj, int s) 852 throws SQLException { 853 throw new SQLException("not supported"); 854 } 855 856 public Statement getStatement() throws SQLException { 857 if (s == null) { 858 throw new SQLException("stale result set"); 859 } 860 return s; 861 } 862 863 public void close() throws SQLException { 864 s = null; 865 tr = null; 866 lastg = null; 867 row = -1; 868 } 869 870 public java.net.URL getURL(int colIndex) throws SQLException { 871 if (tr == null || colIndex < 1 || colIndex > tr.ncolumns) { 872 throw new SQLException("column " + colIndex + " not found"); 873 } 874 String rd[] = (String []) tr.rows.elementAt(row); 875 lastg = rd[colIndex - 1]; 876 java.net.URL url = null; 877 if (lastg == null) { 878 return url; 879 } 880 try { 881 url = new java.net.URL(lastg); 882 } catch (java.lang.Exception e) { 883 url = null; 884 } 885 return url; 886 } 887 888 public java.net.URL getURL(String colIndex) throws SQLException { 889 int col = findColumn(colIndex); 890 return getURL(col); 891 } 892 893 public void updateRef(int colIndex, java.sql.Ref x) throws SQLException { 894 throw new SQLException("not supported"); 895 } 896 897 public void updateRef(String colIndex, java.sql.Ref x) 898 throws SQLException { 899 throw new SQLException("not supported"); 900 } 901 902 public void updateBlob(int colIndex, java.sql.Blob x) 903 throws SQLException { 904 throw new SQLException("not supported"); 905 } 906 907 public void updateBlob(String colIndex, java.sql.Blob x) 908 throws SQLException { 909 throw new SQLException("not supported"); 910 } 911 912 public void updateClob(int colIndex, java.sql.Clob x) 913 throws SQLException { 914 throw new SQLException("not supported"); 915 } 916 917 public void updateClob(String colIndex, java.sql.Clob x) 918 throws SQLException { 919 throw new SQLException("not supported"); 920 } 921 922 public void updateArray(int colIndex, java.sql.Array x) 923 throws SQLException { 924 throw new SQLException("not supported"); 925 } 926 927 public void updateArray(String colIndex, java.sql.Array x) 928 throws SQLException { 929 throw new SQLException("not supported"); 930 } 931 932} 933