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