Java > Open Source Codes > org > apache > derby > vti > VTITemplate


1 /*
2
3    Derby - Class org.apache.derby.vti.VTITemplate
4
5    Licensed to the Apache Software Foundation (ASF) under one or more
6    contributor license agreements. See the NOTICE file distributed with
7    this work for additional information regarding copyright ownership.
8    The ASF licenses this file to You under the Apache License, Version 2.0
9    (the "License"); you may not use this file except in compliance with
10    the License. You may obtain a copy of the License at
11
12       http://www.apache.org/licenses/LICENSE-2.0
13
14    Unless required by applicable law or agreed to in writing, software
15    distributed under the License is distributed on an "AS IS" BASIS,
16    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17    See the License for the specific language governing permissions and
18    limitations under the License.
19
20  */
21
22 package org.apache.derby.vti;
23
24 import java.sql.Connection ;
25 import java.sql.Statement ;
26 import java.sql.ResultSet ;
27 import java.sql.ResultSetMetaData ;
28 import java.sql.SQLException ;
29 import java.sql.SQLWarning ;
30 import java.math.BigDecimal ;
31
32 import java.net.URL ;
33 import java.util.Calendar ;
34 import java.sql.Ref ;
35 import java.sql.Blob ;
36 import java.sql.Clob ;
37 import java.sql.Array ;
38
39 /**
40     An abstract implementation of ResultSet (JDK1.1/JDBC 1.2) that is useful
41     when writing a read-only VTI (virtual table interface) or for
42     the ResultSet returned by executeQuery in read-write VTI classes.
43     
44     This class implements most of the methods of the JDBC 1.2 interface java.sql.ResultSet,
45     each one throwing a SQLException with the name of the method.
46     A concrete subclass can then just implement the methods not implemented here
47     and override any methods it needs to implement for correct functionality.
48     <P>
49     The methods not implemented here are
50     <UL>
51     <LI>next()
52     <LI>close()
53     <LI>getMetaData()
54     </UL>
55     <P>
56
57     For virtual tables the database engine only calls methods defined
58     in the JDBC 1.2 definition of java.sql.ResultSet.
59     <BR>
60     Classes that implement a JDBC 2.0 conformant java.sql.ResultSet can be used
61     as virtual tables.
62  */
63 public abstract class VTITemplate implements ResultSet {
64
65     //
66 // java.sql.ResultSet calls, passed through to our result set.
67 //
68
69     /**
70      * @see java.sql.ResultSet
71      *
72      * @exception SQLException on unexpected JDBC error
73      */
74     public boolean wasNull() throws SQLException {
75         throw new SQLException ("wasNull");
76     }
77
78     /**
79      * @see java.sql.ResultSet
80      *
81      * @exception SQLException on unexpected JDBC error
82      */
83     public String getString(int columnIndex) throws SQLException {
84         throw new SQLException ("getString");
85     }
86
87     /**
88      * @see java.sql.ResultSet
89      *
90      * @exception SQLException on unexpected JDBC error
91      */
92     public boolean getBoolean(int columnIndex) throws SQLException {
93         throw new SQLException ("getBoolean");
94     }
95
96     /**
97      * @see java.sql.ResultSet
98      *
99      * @exception SQLException on unexpected JDBC error
100      */
101     public byte getByte(int columnIndex) throws SQLException {
102         throw new SQLException ("getByte");
103     }
104
105     /**
106      * @see java.sql.ResultSet
107      *
108      * @exception SQLException on unexpected JDBC error
109      */
110     public short getShort(int columnIndex) throws SQLException {
111         throw new SQLException ("getShort");
112     }
113
114     /**
115      * @see java.sql.ResultSet
116      *
117      * @exception SQLException on unexpected JDBC error
118      */
119     public int getInt(int columnIndex) throws SQLException {
120         throw new SQLException ("getInt");
121     }
122
123     /**
124      * @see java.sql.ResultSet
125      *
126      * @exception SQLException on unexpected JDBC error
127      */
128     public long getLong(int columnIndex) throws SQLException {
129         throw new SQLException ("getLong");
130     }
131
132     /**
133      * @see java.sql.ResultSet
134      *
135      * @exception SQLException on unexpected JDBC error
136      */
137    public float getFloat(int columnIndex) throws SQLException {
138         throw new SQLException ("getFloat");
139     }
140
141     /**
142      * @see java.sql.ResultSet
143      *
144      * @exception SQLException on unexpected JDBC error
145      */
146     public double getDouble(int columnIndex) throws SQLException {
147         throw new SQLException ("getDouble");
148     }
149
150     /**
151      * @see java.sql.ResultSet
152      *
153      * @exception SQLException on unexpected JDBC error
154      */
155     public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
156         throw new SQLException ("getBigDecimal");
157     }
158
159     /**
160      * @see java.sql.ResultSet
161      *
162      * @exception SQLException on unexpected JDBC error
163      */
164     public byte[] getBytes(int columnIndex) throws SQLException {
165         throw new SQLException ("getBytes");
166     }
167
168     /**
169      * @see java.sql.ResultSet
170      *
171      * @exception SQLException on unexpected JDBC error
172      */
173     public java.sql.Date getDate(int columnIndex) throws SQLException {
174         throw new SQLException ("getDate");
175     }
176
177     /**
178      * @see java.sql.ResultSet
179      *
180      * @exception SQLException on unexpected JDBC error
181      */
182     public java.sql.Time getTime(int columnIndex) throws SQLException {
183         throw new SQLException ("getTime");
184     }
185
186     /**
187      * @see java.sql.ResultSet
188      *
189      * @exception SQLException on unexpected JDBC error
190      */
191     public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
192         throw new SQLException ("getTimestamp");
193     }
194
195     /**
196      * @see java.sql.ResultSet
197      *
198      * @exception SQLException on unexpected JDBC error
199      */
200     public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
201         throw new SQLException ("getAsciiStream");
202     }
203
204     /**
205      * @see java.sql.ResultSet
206      *
207      * @exception SQLException on unexpected JDBC error
208      */
209     public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
210         throw new SQLException ("getUnicodeStream");
211     }
212
213     /**
214      * @see java.sql.ResultSet
215      *
216      * @exception SQLException on unexpected JDBC error
217      */
218     public java.io.InputStream getBinaryStream(int columnIndex)
219         throws SQLException {
220         throw new SQLException ("getBinaryStream");
221             }
222
223     /**
224      * @see java.sql.ResultSet
225      *
226      * @exception SQLException on unexpected JDBC error
227      */
228     public String getString(String columnName) throws SQLException {
229         return getString(findColumn(columnName));
230     }
231
232     /**
233      * @see java.sql.ResultSet
234      *
235      * @exception SQLException on unexpected JDBC error
236      */
237     public boolean getBoolean(String columnName) throws SQLException {
238         return getBoolean(findColumn(columnName));
239     }
240
241     /**
242      * @see java.sql.ResultSet
243      *
244      * @exception SQLException on unexpected JDBC error
245      */
246     public byte getByte(String columnName) throws SQLException {
247         return getByte(findColumn(columnName));
248     }
249
250     /**
251      * @see java.sql.ResultSet
252      *
253      * @exception SQLException on unexpected JDBC error
254      */
255     public short getShort(String columnName) throws SQLException {
256         return getShort(findColumn(columnName));
257     }
258
259     /**
260      * @see java.sql.ResultSet
261      *
262      * @exception SQLException on unexpected JDBC error
263      */
264     public int getInt(String columnName) throws SQLException {
265         return getInt(findColumn(columnName));
266     }
267
268     /**
269      * @see java.sql.ResultSet
270      *
271      * @exception SQLException on unexpected JDBC error
272      */
273     public long getLong(String columnName) throws SQLException {
274         return getLong(findColumn(columnName));
275     }
276
277     /**
278      * @see java.sql.ResultSet
279      *
280      * @exception SQLException on unexpected JDBC error
281      */
282     public float getFloat(String columnName) throws SQLException {
283         return getFloat(findColumn(columnName));
284     }
285
286     /**
287      * @see java.sql.ResultSet
288      *
289      * @exception SQLException on unexpected JDBC error
290      */
291     public double getDouble(String columnName) throws SQLException {
292         return getDouble(findColumn(columnName));
293     }
294
295     /**
296      * @see java.sql.ResultSet
297      *
298      * @exception SQLException on unexpected JDBC error
299      */
300     public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
301         return getBigDecimal(findColumn(columnName), scale);
302     }
303
304     /**
305      * @see java.sql.ResultSet
306      *
307      * @exception SQLException on unexpected JDBC error
308      */
309     public byte[] getBytes(String columnName) throws SQLException {
310         return getBytes(findColumn(columnName));
311     }
312
313     /**
314      * @see java.sql.ResultSet
315      *
316      * @exception SQLException on unexpected JDBC error
317      */
318     public java.sql.Date getDate(String columnName) throws SQLException {
319         return getDate(findColumn(columnName));
320     }
321
322     /**
323      * @see java.sql.ResultSet
324      *
325      * @exception SQLException on unexpected JDBC error
326      */
327     public java.sql.Time getTime(String columnName) throws SQLException {
328         return getTime(findColumn(columnName));
329     }
330
331     /**
332      * @see java.sql.ResultSet
333      *
334      * @exception SQLException on unexpected JDBC error
335      */
336     public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
337         return getTimestamp(findColumn(columnName));
338     }
339
340     /**
341      * @see java.sql.ResultSet
342      *
343      * @exception SQLException on unexpected JDBC error
344      */
345     public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
346         throw new SQLException ("getAsciiStream");
347     }
348
349     /**
350      * @see java.sql.ResultSet
351      *
352      * @exception SQLException on unexpected JDBC error
353      */
354     public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
355         throw new SQLException ("getUnicodeStream");
356     }
357
358     /**
359      * @see java.sql.ResultSet
360      *
361      * @exception SQLException on unexpected JDBC error
362      */
363     public java.io.InputStream getBinaryStream(String columnName)
364         throws SQLException {
365         throw new SQLException ("getBinaryStream");
366     }
367
368   /**
369     * @exception SQLException if there is an error
370     */
371   public SQLWarning getWarnings() throws SQLException {
372     return null;
373   }
374
375   /**
376     * @exception SQLException if there is an error
377     */
378   public void clearWarnings() throws SQLException {
379   }
380
381     /**
382      * @see java.sql.ResultSet
383      *
384      * @exception SQLException on unexpected JDBC error
385      */
386     public String getCursorName() throws SQLException {
387         throw new SQLException ("getCursorName");
388     }
389
390     /**
391      * @see java.sql.ResultSet
392      *
393      * @exception SQLException on unexpected JDBC error
394      */
395     public Object getObject(int columnIndex) throws SQLException {
396         throw new SQLException ("getObject");
397     }
398
399     /**
400      * @see java.sql.ResultSet
401      *
402      * @exception SQLException on unexpected JDBC error
403      */
404     public Object getObject(String columnName) throws SQLException {
405         return getObject(findColumn(columnName));
406     }
407
408     /**
409      * @see java.sql.ResultSet
410      *
411      * @exception SQLException on unexpected JDBC error
412      */
413     public int findColumn(String columnName) throws SQLException {
414         throw new SQLException ("findColumn");
415     }
416
417     /*
418     ** JDBC 2.0 methods
419     */
420
421     /**
422      * @see java.sql.ResultSet
423      *
424      * @exception SQLException on unexpected JDBC error
425      */
426     public java.io.Reader getCharacterStream(int columnIndex)
427                     throws SQLException {
428         throw new SQLException ("getCharacterStream");
429     }
430
431     /**
432      * @see java.sql.ResultSet
433      *
434      * @exception SQLException on unexpected JDBC error
435      */
436     public java.io.Reader getCharacterStream(String columnName)
437                     throws SQLException {
438         throw new SQLException ("getCharacterStream");
439     }
440
441     /**
442      * @see java.sql.ResultSet
443      *
444      * @exception SQLException on unexpected JDBC error
445      */
446     public BigDecimal getBigDecimal(int columnIndex)
447                     throws SQLException {
448         throw new SQLException ("getBigDecimal");
449     }
450
451     /**
452      * @see java.sql.ResultSet
453      *
454      * @exception SQLException on unexpected JDBC error
455      */
456     public BigDecimal getBigDecimal(String columnName)
457                     throws SQLException {
458         return getBigDecimal(findColumn(columnName));
459     }
460
461     /**
462      * @see java.sql.ResultSet
463      *
464      * @exception SQLException on unexpected JDBC error
465      */
466     public boolean isBeforeFirst()
467                     throws SQLException {
468         throw new SQLException ("isBeforeFirst");
469     }
470
471     /**
472      * @see java.sql.ResultSet
473      *
474      * @exception SQLException on unexpected JDBC error
475      */
476     public boolean isAfterLast()
477                     throws SQLException {
478         throw new SQLException ("isAfterLast");
479     }
480
481     /**
482      * @see java.sql.ResultSet
483      *
484      * @exception SQLException on unexpected JDBC error
485      */
486     public boolean isFirst()
487                     throws SQLException {
488         throw new SQLException ("isFirst");
489     }
490
491     /**
492      * @see java.sql.ResultSet
493      *
494      * @exception SQLException on unexpected JDBC error
495      */
496     public boolean isLast()
497                     throws SQLException {
498         throw new SQLException ("isLast");
499     }
500
501     /**
502      * @see java.sql.ResultSet
503      *
504      * @exception SQLException on unexpected JDBC error
505      */
506     public void beforeFirst()
507                     throws SQLException {
508         throw new SQLException ("beforeFirst");
509     }
510
511     /**
512      * @see java.sql.ResultSet
513      *
514      * @exception SQLException on unexpected JDBC error
515      */
516     public void afterLast()
517                     throws SQLException {
518         throw new SQLException ("afterLast");
519     }
520
521     /**
522      * @see java.sql.ResultSet
523      *
524      * @exception SQLException on unexpected JDBC error
525      */
526     public boolean first()
527                     throws SQLException {
528         throw new SQLException ("first");
529     }
530
531     /**
532      * @see java.sql.ResultSet
533      *
534      * @exception SQLException on unexpected JDBC error
535      */
536     public boolean last()
537                     throws SQLException {
538         throw new SQLException ("last");
539     }
540
541     /**
542      * @see java.sql.ResultSet
543      *
544      * @exception SQLException on unexpected JDBC error
545      */
546     public int getRow()
547                     throws SQLException {
548         throw new SQLException ("getRow");
549     }
550
551     /**
552      * @see java.sql.ResultSet
553      *
554      * @exception SQLException on unexpected JDBC error
555      */
556     public boolean absolute(int row)
557                     throws SQLException {
558         throw new SQLException ("absolute");
559     }
560
561     /**
562      * @see java.sql.ResultSet
563      *
564      * @exception SQLException on unexpected JDBC error
565      */
566     public boolean relative(int rows)
567                     throws SQLException {
568         throw new SQLException ("relative");
569     }
570
571     /**
572      * @see java.sql.ResultSet
573      *
574      * @exception SQLException on unexpected JDBC error
575      */
576     public boolean previous()
577                     throws SQLException {
578         throw new SQLException ("previous");
579     }
580
581     /**
582      * @see java.sql.ResultSet
583      *
584      * @exception SQLException on unexpected JDBC error
585      */
586     public void setFetchDirection(int direction)
587                     throws SQLException {
588         throw new SQLException ("setFetchDirection");
589     }
590
591     /**
592      * @see java.sql.ResultSet
593      *
594      * @exception SQLException on unexpected JDBC error
595      */
596     public int getFetchDirection()
597                     throws SQLException {
598         throw new SQLException ("getFetchDirection");
599     }
600
601     /**
602      * @see java.sql.ResultSet
603      *
604      * @exception SQLException on unexpected JDBC error
605      */
606     public void setFetchSize(int rows)
607                     throws SQLException {
608         throw new SQLException ("setFetchSize");
609     }
610
611     /**
612      * @see java.sql.ResultSet
613      *
614      * @exception SQLException on unexpected JDBC error
615      */
616     public int getFetchSize()
617                     throws SQLException {
618         throw new SQLException ("getFetchSize");
619     }
620
621     /**
622      * @see java.sql.ResultSet
623      *
624      * @exception SQLException on unexpected JDBC error
625      */
626     public int getType()
627                     throws SQLException {
628         throw new SQLException ("getType");
629     }
630
631     /**
632      * @see java.sql.ResultSet
633      *
634      * @exception SQLException on unexpected JDBC error
635      */
636     public int getConcurrency()
637                     throws SQLException {
638         throw new SQLException ("getConcurrency");
639     }
640
641     /**
642      * @see java.sql.ResultSet
643      *
644      * @exception SQLException on unexpected JDBC error
645      */
646     public boolean rowUpdated()
647                     throws SQLException {
648         throw new SQLException ("rowUpdated");
649     }
650
651     /**
652      * @see java.sql.ResultSet
653      *
654      * @exception SQLException on unexpected JDBC error
655      */
656     public boolean rowInserted()
657                     throws SQLException {
658         throw new SQLException ("rowInserted");
659     }
660
661     /**
662      * @see java.sql.ResultSet
663      *
664      * @exception SQLException on unexpected JDBC error
665      */
666     public boolean rowDeleted()
667                     throws SQLException {
668         throw new SQLException ("rowDeleted");
669     }
670
671     /**
672      * @see java.sql.ResultSet
673      *
674      * @exception SQLException on unexpected JDBC error
675      */
676     public void updateNull(int columnIndex)
677                     throws SQLException {
678         throw new SQLException ("updateNull");
679     }
680
681     /**
682      * @see java.sql.ResultSet
683      *
684      * @exception SQLException on unexpected JDBC error
685      */
686     public void updateBoolean(int columnIndex, boolean x)
687                     throws SQLException {
688         throw new SQLException ("updateBoolean");
689     }
690
691     /**
692      * @see java.sql.ResultSet
693      *
694      * @exception SQLException on unexpected JDBC error
695      */
696     public void updateByte(int columnIndex, byte x)
697                     throws SQLException {
698         throw new SQLException ("updateByte");
699     }
700
701     /**
702      * @see java.sql.ResultSet
703      *
704      * @exception SQLException on unexpected JDBC error
705      */
706     public void updateShort(int columnIndex, short x)
707                     throws SQLException {
708         throw new SQLException ("updateShort");
709     }
710
711     /**
712      * @see java.sql.ResultSet
713      *
714      * @exception SQLException on unexpected JDBC error
715      */
716     public void updateInt(int columnIndex, int x)
717                     throws SQLException {
718         throw new SQLException ("updateInt");
719     }
720
721     /**
722      * @see java.sql.ResultSet
723      *
724      * @exception SQLException on unexpected JDBC error
725      */
726     public void updateLong(int columnIndex, long x)
727                     throws SQLException {
728         throw new SQLException ("updateLong");
729     }
730
731     /**
732      * @see java.sql.ResultSet
733      *
734      * @exception SQLException on unexpected JDBC error
735      */
736     public void updateFloat(int columnIndex, float x)
737                     throws SQLException {
738         throw new SQLException ("updateFloat");
739     }
740
741     /**
742      * @see java.sql.ResultSet
743      *
744      * @exception SQLException on unexpected JDBC error
745      */
746     public void updateDouble(int columnIndex, double x)
747                     throws SQLException {
748         throw new SQLException ("updateDouble");
749     }
750
751     /**
752      * @see java.sql.ResultSet
753      *
754      * @exception SQLException on unexpected JDBC error
755      */
756     public void updateBigDecimal(int columnIndex, BigDecimal x)
757                     throws SQLException {
758         throw new SQLException ("updateBigDecimal");
759     }
760
761     /**
762      * @see java.sql.ResultSet
763      *
764      * @exception SQLException on unexpected JDBC error
765      */
766     public void updateString(int columnIndex, String x)
767                     throws SQLException {
768         throw new SQLException ("updateString");
769     }
770
771     /**
772      * @see java.sql.ResultSet
773      *
774      * @exception SQLException on unexpected JDBC error
775      */
776     public void updateBytes(int columnIndex, byte[] x)
777                     throws SQLException {
778         throw new SQLException ("updateBytes");
779     }
780
781     /**
782      * @see java.sql.ResultSet
783      *
784      * @exception SQLException on unexpected JDBC error
785      */
786     public void updateDate(int columnIndex, java.sql.Date x)
787                     throws SQLException {
788         throw new SQLException ("updateDate");
789     }
790
791     /**
792      * @see java.sql.ResultSet
793      *
794      * @exception SQLException on unexpected JDBC error
795      */
796     public void updateTime(int columnIndex, java.sql.Time x)
797                     throws SQLException {
798         throw new SQLException ("updateTime");
799     }
800
801     /**
802      * @see java.sql.ResultSet
803      *
804      * @exception SQLException on unexpected JDBC error
805      */
806     public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
807                     throws SQLException {
808         throw new SQLException ("updateTimestamp");
809     }
810
811     /**
812      * @see java.sql.ResultSet
813      *
814      * @exception SQLException on unexpected JDBC error
815      */
816     public void updateAsciiStream(int columnIndex,
817                             java.io.InputStream x,
818                             int length)
819                     throws SQLException {
820         throw new SQLException ("updateAsciiStream");
821     }
822
823     /**
824      * @see java.sql.ResultSet
825      *
826      * @exception SQLException on unexpected JDBC error
827      */
828     public void updateBinaryStream(int columnIndex,
829                             java.io.InputStream x,
830                             int length)
831                     throws SQLException {
832         throw new SQLException ("updateBinaryStream");
833     }
834
835     /**
836      * @see java.sql.ResultSet
837      *
838      * @exception SQLException on unexpected JDBC error
839      */
840     public void updateCharacterStream(int columnIndex,
841                             java.io.Reader x,
842                             int length)
843                     throws SQLException {
844         throw new SQLException ("updateCharacterStream");
845     }
846
847     /**
848      * @see java.sql.ResultSet
849      *
850      * @exception SQLException on unexpected JDBC error
851      */
852     public void updateObject(int columnIndex,
853                             Object x,
854                             int scale)
855                     throws SQLException {
856         throw new SQLException ("updateObject");
857     }
858
859     /**
860      * @see java.sql.ResultSet
861      *
862      * @exception SQLException on unexpected JDBC error
863      */
864     public void updateObject(int columnIndex, Object x)
865                     throws SQLException {
866         throw new SQLException ("updateObject");
867     }
868
869     /**
870      * @see java.sql.ResultSet
871      *
872      * @exception SQLException on unexpected JDBC error
873      */
874     public void updateNull(String columnName)
875                     throws SQLException {
876         throw new SQLException ("updateNull");
877     }
878
879     /**
880      * @see java.sql.ResultSet
881      *
882      * @exception SQLException on unexpected JDBC error
883      */
884     public void updateBoolean(String columnName, boolean x)
885                     throws SQLException {
886         throw new SQLException ("updateBoolean");
887     }
888
889     /**
890      * @see java.sql.ResultSet
891      *
892      * @exception SQLException on unexpected JDBC error
893      */
894     public void updateByte(String columnName, byte x)
895                     throws SQLException {
896         throw new SQLException ("updateByte");
897     }
898
899     /**
900      * @see java.sql.ResultSet
901      *
902      * @exception SQLException on unexpected JDBC error
903      */
904     public void updateShort(String columnName, short x)
905                     throws SQLException {
906         throw new SQLException ("updateShort");
907     }
908
909     /**
910      * @see java.sql.ResultSet
911      *
912      * @exception SQLException on unexpected JDBC error
913      */
914     public void updateInt(String columnName, int x)
915                     throws SQLException {
916         throw new SQLException ("updateInt");
917     }
918
919     /**
920      * @see java.sql.ResultSet
921      *
922      * @exception SQLException on unexpected JDBC error
923      */
924     public void updateLong(String columnName, long x)
925                     throws SQLException {
926         throw new SQLException ("updateLong");
927     }
928
929     /**
930      * @see java.sql.ResultSet
931      *
932      * @exception SQLException on unexpected JDBC error
933      */
934     public void updateFloat(String columnName, float x)
935                     throws SQLException {
936         throw new SQLException ("updateFloat");
937     }
938
939     /**
940      * @see java.sql.ResultSet
941      *
942      * @exception SQLException on unexpected JDBC error
943      */
944     public void updateDouble(String columnName, double x)
945                     throws SQLException {
946         throw new SQLException ("updateDouble");
947     }
948
949     /**
950      * @see java.sql.ResultSet
951      *
952      * @exception SQLException on unexpected JDBC error
953      */
954     public void updateBigDecimal(String columnName, BigDecimal x)
955                     throws SQLException {
956         throw new SQLException ("updateBigDecimal");
957     }
958
959     /**
960      * @see java.sql.ResultSet
961      *
962      * @exception SQLException on unexpected JDBC error
963      */
964     public void updateString(String columnName, String x)
965                     throws SQLException {
966         throw new SQLException ("updateString");
967     }
968
969     /**
970      * @see java.sql.ResultSet
971      *
972      * @exception SQLException on unexpected JDBC error
973      */
974     public void updateBytes(String columnName, byte[] x)
975                     throws SQLException {
976         throw new SQLException ("updateBytes");
977     }
978
979     /**
980      * @see java.sql.ResultSet
981      *
982      * @exception SQLException on unexpected JDBC error
983      */
984     public void updateDate(String columnName, java.sql.Date x)
985                     throws SQLException {
986         throw new SQLException ("updateDate");
987     }
988
989     /**
990      * @see java.sql.ResultSet
991      *
992      * @exception SQLException on unexpected JDBC error
993      */
994     public void updateTime(String columnName, java.sql.Time x)
995                     throws SQLException {
996         throw new SQLException ("updateTime");
997     }
998
999     /**
1000     * @see java.sql.ResultSet
1001     *
1002     * @exception SQLException on unexpected JDBC error
1003     */
1004    public void updateTimestamp(String columnName, java.sql.Timestamp x)
1005                    throws SQLException {
1006        throw new SQLException ("updateTimestamp");
1007    }
1008
1009    /**
1010     * @see java.sql.ResultSet
1011     *
1012     * @exception SQLException on unexpected JDBC error
1013     */
1014    public void updateAsciiStream(String columnName,
1015                            java.io.InputStream x,
1016                            int length)
1017                    throws SQLException {
1018        throw new SQLException ("updateAsciiStream");
1019    }
1020
1021    /**
1022     * @see java.sql.ResultSet
1023     *
1024     * @exception SQLException on unexpected JDBC error
1025     */
1026    public void updateBinaryStream(String columnName,
1027                            java.io.InputStream x,
1028                            int length)
1029                    throws SQLException {
1030        throw new SQLException ("updateBinaryStream");
1031    }
1032
1033    /**
1034     * @see java.sql.ResultSet
1035     *
1036     * @exception SQLException on unexpected JDBC error
1037     */
1038    public void updateCharacterStream(String columnName,
1039                            java.io.Reader x,
1040                            int length)
1041                    throws SQLException {
1042        throw new SQLException ("updateCharacterStream");
1043    }
1044
1045    /**
1046     * @see java.sql.ResultSet
1047     *
1048     * @exception SQLException on unexpected JDBC error
1049     */
1050    public void updateObject(String columnName,
1051                            Object x,
1052                            int scale)
1053                    throws SQLException {
1054        throw new SQLException ("updateObject");
1055    }
1056
1057    /**
1058     * @see java.sql.ResultSet
1059     *
1060     * @exception SQLException on unexpected JDBC error
1061     */
1062    public void updateObject(String columnName, Object x)
1063                    throws SQLException {
1064        throw new SQLException ("updateObject");
1065    }
1066
1067    /**
1068     * @see java.sql.ResultSet
1069     *
1070     * @exception SQLException on unexpected JDBC error
1071     */
1072    public void insertRow()
1073                    throws SQLException {
1074        throw new SQLException ("insertRow");
1075    }
1076
1077    /**
1078     * @see java.sql.ResultSet
1079     *
1080     * @exception SQLException on unexpected JDBC error
1081     */
1082    public void updateRow()
1083                    throws SQLException {
1084        throw new SQLException ("updateRow");
1085    }
1086
1087    /**
1088     * @see java.sql.ResultSet
1089     *
1090     * @exception SQLException on unexpected JDBC error
1091     */
1092    public void deleteRow()
1093                    throws SQLException {
1094        throw new SQLException ("deleteRow");
1095    }
1096
1097    /**
1098     * @see java.sql.ResultSet
1099     *
1100     * @exception SQLException on unexpected JDBC error
1101     */
1102    public void refreshRow()
1103                    throws SQLException {
1104        throw new SQLException ("refreshRow");
1105    }
1106
1107    /**
1108     * @see java.sql.ResultSet
1109     *
1110     * @exception SQLException on unexpected JDBC error
1111     */
1112    public void cancelRowUpdates()
1113                    throws SQLException {
1114        throw new SQLException ("cancelRowUpdates");
1115    }
1116
1117    /**
1118     * @see java.sql.ResultSet
1119     *
1120     * @exception SQLException on unexpected JDBC error
1121     */
1122    public void moveToInsertRow()
1123                    throws SQLException {
1124        throw new SQLException ("moveToInsertRow");
1125    }
1126
1127    /**
1128     * @see java.sql.ResultSet
1129     *
1130     * @exception SQLException on unexpected JDBC error
1131     */
1132    public void moveToCurrentRow()
1133                    throws SQLException {
1134        throw new SQLException ("moveToCurrentRow");
1135    }
1136
1137    /**
1138     * @see java.sql.ResultSet
1139     *
1140     * @exception SQLException on unexpected JDBC error
1141     */
1142    public Statement getStatement()
1143                    throws SQLException {
1144        throw new SQLException ("getStatement");
1145    }
1146    /**
1147     * @see java.sql.ResultSet
1148     *
1149     * @exception SQLException on unexpected JDBC error
1150     */
1151    public java.sql.Date getDate(int columnIndex, Calendar cal)
1152                    throws SQLException {
1153        throw new SQLException ("getDate");
1154    }
1155
1156    /**
1157     * @see java.sql.ResultSet
1158     *
1159     * @exception SQLException on unexpected JDBC error
1160     */
1161    public java.sql.Date getDate(String columnName, Calendar cal)
1162                    throws SQLException {
1163        throw new SQLException ("getDate");
1164    }
1165
1166    /**
1167     * @see java.sql.ResultSet
1168     *
1169     * @exception SQLException on unexpected JDBC error
1170     */
1171    public java.sql.Time getTime(int columnIndex, Calendar cal)
1172                    throws SQLException {
1173        throw new SQLException ("getTime");
1174    }
1175
1176    /**
1177     * @see java.sql.ResultSet
1178     *
1179     * @exception SQLException on unexpected JDBC error
1180     */
1181    public java.sql.Time getTime(String columnName, Calendar cal)
1182                    throws SQLException {
1183        throw new SQLException ("getTime");
1184    }
1185
1186    /**
1187     * @see java.sql.ResultSet
1188     *
1189     * @exception SQLException on unexpected JDBC error
1190     */
1191    public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
1192                    throws SQLException {
1193        throw new SQLException ("getTimestamp");
1194    }
1195
1196    /**
1197     * @see java.sql.ResultSet
1198     *
1199     * @exception SQLException on unexpected JDBC error
1200     */
1201    public java.sql.Timestamp getTimestamp(String columnName, Calendar cal)
1202                    throws SQLException {
1203        throw new SQLException ("getTimestamp");
1204    }
1205    /*
1206    ** JDBC 3.0 methods
1207    */
1208    
1209    /**
1210     * @see java.sql.ResultSet
1211     *
1212     * @exception SQLException on unexpected JDBC error
1213     */
1214    public URL getURL(int columnIndex)
1215    throws SQLException
1216    {
1217        throw new SQLException ("getURL");
1218    }
1219
1220    /**
1221     * @see java.sql.ResultSet
1222     *
1223     * @exception SQLException on unexpected JDBC error
1224     */
1225    public URL getURL(String columnName)
1226                    throws SQLException {
1227        throw new SQLException ("getURL");
1228    }
1229
1230    /**
1231     * @see java.sql.ResultSet
1232     *
1233     * @exception SQLException on unexpected JDBC error
1234     */
1235    public Object getObject(int i, java.util.Map map)
1236                    throws SQLException {
1237        throw new SQLException ("getObject");
1238    }
1239
1240    /**
1241     * @see java.sql.ResultSet
1242     *
1243     * @exception SQLException on unexpected JDBC error
1244     */
1245    public Ref getRef(int i)
1246                    throws SQLException {
1247        throw new SQLException ("getRef");
1248    }
1249
1250    /**
1251     * @see java.sql.ResultSet
1252     *
1253     * @exception SQLException on unexpected JDBC error
1254     */
1255    public Blob getBlob(int i)
1256                    throws SQLException {
1257        throw new SQLException ("getBlob");
1258    }
1259
1260    /**
1261     * @see java.sql.ResultSet
1262     *
1263     * @exception SQLException on unexpected JDBC error
1264     */
1265    public Clob getClob(int i)
1266                    throws SQLException {
1267        throw new SQLException ("getClob");
1268    }
1269
1270    /**
1271     * @see java.sql.ResultSet
1272     *
1273     * @exception SQLException on unexpected JDBC error
1274     */
1275    public Array getArray(int i)
1276                    throws SQLException {
1277        throw new SQLException ("getArray");
1278    }
1279
1280    /**
1281     * @see java.sql.ResultSet
1282     *
1283     * @exception SQLException on unexpected JDBC error
1284     */
1285    public Object getObject(String colName, java.util.Map map)
1286                    throws SQLException {
1287        throw new SQLException ("getObject");
1288    }
1289
1290    /**
1291     * @see java.sql.ResultSet
1292     *
1293     * @exception SQLException on unexpected JDBC error
1294     */
1295    public Ref getRef(String colName)
1296                    throws SQLException {
1297        throw new SQLException ("getRef");
1298    }
1299
1300    /**
1301     * @see java.sql.ResultSet
1302     *
1303     * @exception SQLException on unexpected JDBC error
1304     */
1305    public Blob getBlob(String colName)
1306                    throws SQLException {
1307        throw new SQLException ("getBlob");
1308    }
1309
1310    /**
1311     * @see java.sql.ResultSet
1312     *
1313     * @exception SQLException on unexpected JDBC error
1314     */
1315    public Clob getClob(String colName)
1316                    throws SQLException {
1317        throw new SQLException ("getClob");
1318    }
1319
1320    /**
1321     * @see java.sql.ResultSet
1322     *
1323     * @exception SQLException on unexpected JDBC error
1324     */
1325    public Array getArray(String colName)
1326                    throws SQLException {
1327        throw new SQLException ("getArray");
1328    }
1329
1330
1331    // JDBC 3.0 methods - not implemented
1332
1333    /**
1334     * @see java.sql.ResultSet
1335     *
1336     * @exception SQLException on unexpected JDBC error
1337     */
1338    public void updateRef(int columnIndex, Ref x)
1339                    throws SQLException {
1340        throw new SQLException ("updateRef");
1341    }
1342
1343    /**
1344     * @see java.sql.ResultSet
1345     *
1346     * @exception SQLException on unexpected JDBC error
1347     */
1348    public void updateRef(String columnName, Ref x)
1349                    throws SQLException {
1350        throw new SQLException ("updateRef");
1351    }
1352
1353    /**
1354     * @see java.sql.ResultSet
1355     *
1356     * @exception SQLException on unexpected JDBC error
1357     */
1358    public void updateBlob(int columnIndex, Blob x)
1359                    throws SQLException {
1360        throw new SQLException ("updateBlob");
1361    }
1362
1363    /**
1364     * @see java.sql.ResultSet
1365     *
1366     * @exception SQLException on unexpected JDBC error
1367     */
1368    public void updateBlob(String columnName, Blob x)
1369                    throws SQLException {
1370        throw new SQLException ("updateBlob");
1371    }
1372
1373    /**
1374     * @see java.sql.ResultSet
1375     *
1376     * @exception SQLException on unexpected JDBC error
1377     */
1378    public void updateClob(int columnIndex, Clob x)
1379                    throws SQLException {
1380        throw new SQLException ("updateClob");
1381    }
1382
1383    /**
1384     * @see java.sql.ResultSet
1385     *
1386     * @exception SQLException on unexpected JDBC error
1387     */
1388    public void updateClob(String columnName, Clob x)
1389                    throws SQLException {
1390        throw new SQLException ("updateClob");
1391    }
1392
1393    /**
1394     * @see java.sql.ResultSet
1395     *
1396     * @exception SQLException on unexpected JDBC error
1397     */
1398    public void updateArray(int columnIndex, Array x)
1399                    throws SQLException {
1400        throw new SQLException ("updateArray");
1401    }
1402
1403    /**
1404     * @see java.sql.ResultSet
1405     *
1406     * @exception SQLException on unexpected JDBC error
1407     */
1408    public void updateArray(String columnName, Array x)
1409                    throws SQLException {
1410        throw new SQLException ("updateArray");
1411    }
1412}
1413

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags