KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > derbyTesting > functionTests > tests > lang > TableVTI


1 /*
2
3 Derby - Class org.apache.derbyTesting.functionTests.tests.lang.TableVTI
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.derbyTesting.functionTests.tests.lang;
23
24 import java.sql.Connection JavaDoc;
25 import java.sql.Statement JavaDoc;
26 import java.sql.ResultSet JavaDoc;
27 import java.sql.ResultSetMetaData JavaDoc;
28 import java.sql.SQLException JavaDoc;
29 import java.sql.SQLWarning JavaDoc;
30 import java.math.BigDecimal JavaDoc;
31 import java.sql.DriverManager JavaDoc;
32 import java.net.URL JavaDoc;
33 import java.util.Calendar JavaDoc;
34 import java.sql.Ref JavaDoc;
35 import java.sql.Blob JavaDoc;
36 import java.sql.Clob JavaDoc;
37 import java.sql.Array JavaDoc;
38
39 /**
40     This class has been adapted from org.apache.derby.vti.VTITemplate
41     because we do not want a test to depend on an engine class.
42    
43     This class implements most of the methods of the JDBC 1.2 interface java.sql.ResultSet,
44     each one throwing a SQLException with the name of the method.
45     A concrete subclass can then just implement the methods not implemented here
46     and override any methods it needs to implement for correct functionality.
47     <P>
48     The methods not implemented here are
49     <UL>
50     <LI>next()
51     <LI>close()
52     <LI>getMetaData()
53     </UL>
54     <P>
55
56     For virtual tables the database engine only calls methods defined
57     in the JDBC 1.2 definition of java.sql.ResultSet.
58     <BR>
59     Classes that implement a JDBC 2.0 conformant java.sql.ResultSet can be used
60     as virtual tables.
61 */

62 public abstract class TableVTI implements ResultSet JavaDoc {
63     
64     private String JavaDoc tableName;
65     private ResultSetMetaData JavaDoc rsmd ;
66     private int[] map;
67     public TableVTI(String JavaDoc tableName) throws SQLException JavaDoc {
68         this.tableName = tableName;
69         init();
70     }
71     
72     protected void init() throws SQLException JavaDoc {
73         Connection JavaDoc conn = DriverManager
74         .getConnection("jdbc:default:connection");
75         Statement JavaDoc s = conn.createStatement();
76         ResultSet JavaDoc rs = s.executeQuery("select * from " + tableName
77                 + " where 1 = 0 ");
78         rsmd = rs.getMetaData();
79         rs.close();
80         s.close();
81         
82         map = getColumnMap(getVTIColumnNames());
83     }
84     
85     public final ResultSetMetaData JavaDoc getMetaData() {
86         return rsmd;
87     }
88     
89     public final void close() {
90     }
91     
92     protected int[] getColumnMap(String JavaDoc[] vtiNames) throws SQLException JavaDoc {
93         
94         if (vtiNames == null)
95             return null;
96         
97         int[] map = new int[vtiNames.length];
98         int count = rsmd.getColumnCount();
99         
100         outer: for (int i = 0; i < vtiNames.length; i++) {
101             
102             String JavaDoc vtiCol = vtiNames[i];
103             if (vtiCol == null)
104                 continue outer;
105             ;
106             
107             for (int j = 1; j <= count; j++) {
108                 if (vtiCol.equalsIgnoreCase(rsmd.getColumnName(j))) {
109                     map[i] = j;
110                     continue outer;
111                 }
112             }
113         }
114         
115         return map;
116     }
117     
118     protected String JavaDoc[] getVTIColumnNames() {
119         return null;
120     }
121     
122     //
123
// java.sql.ResultSet calls, passed through to our result set.
124
//
125

126     /**
127      * @see java.sql.ResultSet
128      *
129      * @exception SQLException on unexpected JDBC error
130      */

131     public boolean wasNull() throws SQLException JavaDoc {
132         throw new SQLException JavaDoc("wasNull");
133     }
134     
135     /**
136      * @see java.sql.ResultSet
137      *
138      * @exception SQLException on unexpected JDBC error
139      */

140     public String JavaDoc getString(int columnIndex) throws SQLException JavaDoc {
141         throw new SQLException JavaDoc("getString");
142     }
143     
144     /**
145      * @see java.sql.ResultSet
146      *
147      * @exception SQLException on unexpected JDBC error
148      */

149     public boolean getBoolean(int columnIndex) throws SQLException JavaDoc {
150         throw new SQLException JavaDoc("getBoolean");
151     }
152     
153     /**
154      * @see java.sql.ResultSet
155      *
156      * @exception SQLException on unexpected JDBC error
157      */

158     public byte getByte(int columnIndex) throws SQLException JavaDoc {
159         throw new SQLException JavaDoc("getByte");
160     }
161     
162     /**
163      * @see java.sql.ResultSet
164      *
165      * @exception SQLException on unexpected JDBC error
166      */

167     public short getShort(int columnIndex) throws SQLException JavaDoc {
168         throw new SQLException JavaDoc("getShort");
169     }
170     
171     /**
172      * @see java.sql.ResultSet
173      *
174      * @exception SQLException on unexpected JDBC error
175      */

176     public int getInt(int columnIndex) throws SQLException JavaDoc {
177         throw new SQLException JavaDoc("getInt");
178     }
179     
180     /**
181      * @see java.sql.ResultSet
182      *
183      * @exception SQLException on unexpected JDBC error
184      */

185     public long getLong(int columnIndex) throws SQLException JavaDoc {
186         throw new SQLException JavaDoc("getLong");
187     }
188     
189     /**
190      * @see java.sql.ResultSet
191      *
192      * @exception SQLException on unexpected JDBC error
193      */

194     public float getFloat(int columnIndex) throws SQLException JavaDoc {
195         throw new SQLException JavaDoc("getFloat");
196     }
197     
198     /**
199      * @see java.sql.ResultSet
200      *
201      * @exception SQLException on unexpected JDBC error
202      */

203     public double getDouble(int columnIndex) throws SQLException JavaDoc {
204         throw new SQLException JavaDoc("getDouble");
205     }
206     
207     /**
208      * @see java.sql.ResultSet
209      *
210      * @exception SQLException on unexpected JDBC error
211      */

212     public BigDecimal JavaDoc getBigDecimal(int columnIndex, int scale) throws SQLException JavaDoc {
213         throw new SQLException JavaDoc("getBigDecimal");
214     }
215     
216     /**
217      * @see java.sql.ResultSet
218      *
219      * @exception SQLException on unexpected JDBC error
220      */

221     public byte[] getBytes(int columnIndex) throws SQLException JavaDoc {
222         throw new SQLException JavaDoc("getBytes");
223     }
224     
225     /**
226      * @see java.sql.ResultSet
227      *
228      * @exception SQLException on unexpected JDBC error
229      */

230     public java.sql.Date JavaDoc getDate(int columnIndex) throws SQLException JavaDoc {
231         throw new SQLException JavaDoc("getDate");
232     }
233     
234     /**
235      * @see java.sql.ResultSet
236      *
237      * @exception SQLException on unexpected JDBC error
238      */

239     public java.sql.Time JavaDoc getTime(int columnIndex) throws SQLException JavaDoc {
240         throw new SQLException JavaDoc("getTime");
241     }
242     
243     /**
244      * @see java.sql.ResultSet
245      *
246      * @exception SQLException on unexpected JDBC error
247      */

248     public java.sql.Timestamp JavaDoc getTimestamp(int columnIndex) throws SQLException JavaDoc {
249         throw new SQLException JavaDoc("getTimestamp");
250     }
251     
252     /**
253      * @see java.sql.ResultSet
254      *
255      * @exception SQLException on unexpected JDBC error
256      */

257     public java.io.InputStream JavaDoc getAsciiStream(int columnIndex) throws SQLException JavaDoc {
258         throw new SQLException JavaDoc("getAsciiStream");
259     }
260     
261     /**
262      * @see java.sql.ResultSet
263      *
264      * @exception SQLException on unexpected JDBC error
265      */

266     public java.io.InputStream JavaDoc getUnicodeStream(int columnIndex) throws SQLException JavaDoc {
267         throw new SQLException JavaDoc("getUnicodeStream");
268     }
269     
270     /**
271      * @see java.sql.ResultSet
272      *
273      * @exception SQLException on unexpected JDBC error
274      */

275     public java.io.InputStream JavaDoc getBinaryStream(int columnIndex)
276     throws SQLException JavaDoc {
277         throw new SQLException JavaDoc("getBinaryStream");
278     }
279     
280     /**
281      * @see java.sql.ResultSet
282      *
283      * @exception SQLException on unexpected JDBC error
284      */

285     public String JavaDoc getString(String JavaDoc columnName) throws SQLException JavaDoc {
286         return getString(findColumn(columnName));
287     }
288     
289     /**
290      * @see java.sql.ResultSet
291      *
292      * @exception SQLException on unexpected JDBC error
293      */

294     public boolean getBoolean(String JavaDoc columnName) throws SQLException JavaDoc {
295         return getBoolean(findColumn(columnName));
296     }
297     
298     /**
299      * @see java.sql.ResultSet
300      *
301      * @exception SQLException on unexpected JDBC error
302      */

303     public byte getByte(String JavaDoc columnName) throws SQLException JavaDoc {
304         return getByte(findColumn(columnName));
305     }
306     
307     /**
308      * @see java.sql.ResultSet
309      *
310      * @exception SQLException on unexpected JDBC error
311      */

312     public short getShort(String JavaDoc columnName) throws SQLException JavaDoc {
313         return getShort(findColumn(columnName));
314     }
315     
316     /**
317      * @see java.sql.ResultSet
318      *
319      * @exception SQLException on unexpected JDBC error
320      */

321     public int getInt(String JavaDoc columnName) throws SQLException JavaDoc {
322         return getInt(findColumn(columnName));
323     }
324     
325     /**
326      * @see java.sql.ResultSet
327      *
328      * @exception SQLException on unexpected JDBC error
329      */

330     public long getLong(String JavaDoc columnName) throws SQLException JavaDoc {
331         return getLong(findColumn(columnName));
332     }
333     
334     /**
335      * @see java.sql.ResultSet
336      *
337      * @exception SQLException on unexpected JDBC error
338      */

339     public float getFloat(String JavaDoc columnName) throws SQLException JavaDoc {
340         return getFloat(findColumn(columnName));
341     }
342     
343     /**
344      * @see java.sql.ResultSet
345      *
346      * @exception SQLException on unexpected JDBC error
347      */

348     public double getDouble(String JavaDoc columnName) throws SQLException JavaDoc {
349         return getDouble(findColumn(columnName));
350     }
351     
352     /**
353      * @see java.sql.ResultSet
354      *
355      * @exception SQLException on unexpected JDBC error
356      */

357     public BigDecimal JavaDoc getBigDecimal(String JavaDoc columnName, int scale) throws SQLException JavaDoc {
358         return getBigDecimal(findColumn(columnName), scale);
359     }
360     
361     /**
362      * @see java.sql.ResultSet
363      *
364      * @exception SQLException on unexpected JDBC error
365      */

366     public byte[] getBytes(String JavaDoc columnName) throws SQLException JavaDoc {
367         return getBytes(findColumn(columnName));
368     }
369     
370     /**
371      * @see java.sql.ResultSet
372      *
373      * @exception SQLException on unexpected JDBC error
374      */

375     public java.sql.Date JavaDoc getDate(String JavaDoc columnName) throws SQLException JavaDoc {
376         return getDate(findColumn(columnName));
377     }
378     
379     /**
380      * @see java.sql.ResultSet
381      *
382      * @exception SQLException on unexpected JDBC error
383      */

384     public java.sql.Time JavaDoc getTime(String JavaDoc columnName) throws SQLException JavaDoc {
385         return getTime(findColumn(columnName));
386     }
387     
388     /**
389      * @see java.sql.ResultSet
390      *
391      * @exception SQLException on unexpected JDBC error
392      */

393     public java.sql.Timestamp JavaDoc getTimestamp(String JavaDoc columnName) throws SQLException JavaDoc {
394         return getTimestamp(findColumn(columnName));
395     }
396     
397     /**
398      * @see java.sql.ResultSet
399      *
400      * @exception SQLException on unexpected JDBC error
401      */

402     public java.io.InputStream JavaDoc getAsciiStream(String JavaDoc columnName) throws SQLException JavaDoc {
403         throw new SQLException JavaDoc("getAsciiStream");
404     }
405     
406     /**
407      * @see java.sql.ResultSet
408      *
409      * @exception SQLException on unexpected JDBC error
410      */

411     public java.io.InputStream JavaDoc getUnicodeStream(String JavaDoc columnName) throws SQLException JavaDoc {
412         throw new SQLException JavaDoc("getUnicodeStream");
413     }
414     
415     /**
416      * @see java.sql.ResultSet
417      *
418      * @exception SQLException on unexpected JDBC error
419      */

420     public java.io.InputStream JavaDoc getBinaryStream(String JavaDoc columnName)
421     throws SQLException JavaDoc {
422         throw new SQLException JavaDoc("getBinaryStream");
423     }
424     
425     /**
426      * @exception SQLException if there is an error
427      */

428     public SQLWarning JavaDoc getWarnings() throws SQLException JavaDoc {
429         return null;
430     }
431     
432     /**
433      * @exception SQLException if there is an error
434      */

435     public void clearWarnings() throws SQLException JavaDoc {
436     }
437     
438     /**
439      * @see java.sql.ResultSet
440      *
441      * @exception SQLException on unexpected JDBC error
442      */

443     public String JavaDoc getCursorName() throws SQLException JavaDoc {
444         throw new SQLException JavaDoc("getCursorName");
445     }
446     
447     /**
448      * @see java.sql.ResultSet
449      *
450      * @exception SQLException on unexpected JDBC error
451      */

452     public Object JavaDoc getObject(int columnIndex) throws SQLException JavaDoc {
453         throw new SQLException JavaDoc("getObject");
454     }
455     
456     /**
457      * @see java.sql.ResultSet
458      *
459      * @exception SQLException on unexpected JDBC error
460      */

461     public Object JavaDoc getObject(String JavaDoc columnName) throws SQLException JavaDoc {
462         return getObject(findColumn(columnName));
463     }
464     
465     /**
466      * @see java.sql.ResultSet
467      *
468      * @exception SQLException on unexpected JDBC error
469      */

470     public int findColumn(String JavaDoc columnName) throws SQLException JavaDoc {
471         throw new SQLException JavaDoc("findColumn");
472     }
473     
474     /*
475      ** JDBC 2.0 methods
476      */

477     
478     /**
479      * @see java.sql.ResultSet
480      *
481      * @exception SQLException on unexpected JDBC error
482      */

483     public java.io.Reader JavaDoc getCharacterStream(int columnIndex)
484     throws SQLException JavaDoc {
485         throw new SQLException JavaDoc("getCharacterStream");
486     }
487     
488     /**
489      * @see java.sql.ResultSet
490      *
491      * @exception SQLException on unexpected JDBC error
492      */

493     public java.io.Reader JavaDoc getCharacterStream(String JavaDoc columnName)
494     throws SQLException JavaDoc {
495         throw new SQLException JavaDoc("getCharacterStream");
496     }
497     
498     /**
499      * @see java.sql.ResultSet
500      *
501      * @exception SQLException on unexpected JDBC error
502      */

503     public BigDecimal JavaDoc getBigDecimal(int columnIndex)
504     throws SQLException JavaDoc {
505         throw new SQLException JavaDoc("getBigDecimal");
506     }
507     
508     /**
509      * @see java.sql.ResultSet
510      *
511      * @exception SQLException on unexpected JDBC error
512      */

513     public BigDecimal JavaDoc getBigDecimal(String JavaDoc columnName)
514     throws SQLException JavaDoc {
515         return getBigDecimal(findColumn(columnName));
516     }
517     
518     /**
519      * @see java.sql.ResultSet
520      *
521      * @exception SQLException on unexpected JDBC error
522      */

523     public boolean isBeforeFirst()
524     throws SQLException JavaDoc {
525         throw new SQLException JavaDoc("isBeforeFirst");
526     }
527     
528     /**
529      * @see java.sql.ResultSet
530      *
531      * @exception SQLException on unexpected JDBC error
532      */

533     public boolean isAfterLast()
534     throws SQLException JavaDoc {
535         throw new SQLException JavaDoc("isAfterLast");
536     }
537     
538     /**
539      * @see java.sql.ResultSet
540      *
541      * @exception SQLException on unexpected JDBC error
542      */

543     public boolean isFirst()
544     throws SQLException JavaDoc {
545         throw new SQLException JavaDoc("isFirst");
546     }
547     
548     /**
549      * @see java.sql.ResultSet
550      *
551      * @exception SQLException on unexpected JDBC error
552      */

553     public boolean isLast()
554     throws SQLException JavaDoc {
555         throw new SQLException JavaDoc("isLast");
556     }
557     
558     /**
559      * @see java.sql.ResultSet
560      *
561      * @exception SQLException on unexpected JDBC error
562      */

563     public void beforeFirst()
564     throws SQLException JavaDoc {
565         throw new SQLException JavaDoc("beforeFirst");
566     }
567     
568     /**
569      * @see java.sql.ResultSet
570      *
571      * @exception SQLException on unexpected JDBC error
572      */

573     public void afterLast()
574     throws SQLException JavaDoc {
575         throw new SQLException JavaDoc("afterLast");
576     }
577     
578     /**
579      * @see java.sql.ResultSet
580      *
581      * @exception SQLException on unexpected JDBC error
582      */

583     public boolean first()
584     throws SQLException JavaDoc {
585         throw new SQLException JavaDoc("first");
586     }
587     
588     /**
589      * @see java.sql.ResultSet
590      *
591      * @exception SQLException on unexpected JDBC error
592      */

593     public boolean last()
594     throws SQLException JavaDoc {
595         throw new SQLException JavaDoc("last");
596     }
597     
598     /**
599      * @see java.sql.ResultSet
600      *
601      * @exception SQLException on unexpected JDBC error
602      */

603     public int getRow()
604     throws SQLException JavaDoc {
605         throw new SQLException JavaDoc("getRow");
606     }
607     
608     /**
609      * @see java.sql.ResultSet
610      *
611      * @exception SQLException on unexpected JDBC error
612      */

613     public boolean absolute(int row)
614     throws SQLException JavaDoc {
615         throw new SQLException JavaDoc("absolute");
616     }
617     
618     /**
619      * @see java.sql.ResultSet
620      *
621      * @exception SQLException on unexpected JDBC error
622      */

623     public boolean relative(int rows)
624     throws SQLException JavaDoc {
625         throw new SQLException JavaDoc("relative");
626     }
627     
628     /**
629      * @see java.sql.ResultSet
630      *
631      * @exception SQLException on unexpected JDBC error
632      */

633     public boolean previous()
634     throws SQLException JavaDoc {
635         throw new SQLException JavaDoc("previous");
636     }
637     
638     /**
639      * @see java.sql.ResultSet
640      *
641      * @exception SQLException on unexpected JDBC error
642      */

643     public void setFetchDirection(int direction)
644     throws SQLException JavaDoc {
645         throw new SQLException JavaDoc("setFetchDirection");
646     }
647     
648     /**
649      * @see java.sql.ResultSet
650      *
651      * @exception SQLException on unexpected JDBC error
652      */

653     public int getFetchDirection()
654     throws SQLException JavaDoc {
655         throw new SQLException JavaDoc("getFetchDirection");
656     }
657     
658     /**
659      * @see java.sql.ResultSet
660      *
661      * @exception SQLException on unexpected JDBC error
662      */

663     public void setFetchSize(int rows)
664     throws SQLException JavaDoc {
665         throw new SQLException JavaDoc("setFetchSize");
666     }
667     
668     /**
669      * @see java.sql.ResultSet
670      *
671      * @exception SQLException on unexpected JDBC error
672      */

673     public int getFetchSize()
674     throws SQLException JavaDoc {
675         throw new SQLException JavaDoc("getFetchSize");
676     }
677     
678     /**
679      * @see java.sql.ResultSet
680      *
681      * @exception SQLException on unexpected JDBC error
682      */

683     public int getType()
684     throws SQLException JavaDoc {
685         throw new SQLException JavaDoc("getType");
686     }
687     
688     /**
689      * @see java.sql.ResultSet
690      *
691      * @exception SQLException on unexpected JDBC error
692      */

693     public int getConcurrency()
694     throws SQLException JavaDoc {
695         throw new SQLException JavaDoc("getConcurrency");
696     }
697     
698     /**
699      * @see java.sql.ResultSet
700      *
701      * @exception SQLException on unexpected JDBC error
702      */

703     public boolean rowUpdated()
704     throws SQLException JavaDoc {
705         throw new SQLException JavaDoc("rowUpdated");
706     }
707     
708     /**
709      * @see java.sql.ResultSet
710      *
711      * @exception SQLException on unexpected JDBC error
712      */

713     public boolean rowInserted()
714     throws SQLException JavaDoc {
715         throw new SQLException JavaDoc("rowInserted");
716     }
717     
718     /**
719      * @see java.sql.ResultSet
720      *
721      * @exception SQLException on unexpected JDBC error
722      */

723     public boolean rowDeleted()
724     throws SQLException JavaDoc {
725         throw new SQLException JavaDoc("rowDeleted");
726     }
727     
728     /**
729      * @see java.sql.ResultSet
730      *
731      * @exception SQLException on unexpected JDBC error
732      */

733     public void updateNull(int columnIndex)
734     throws SQLException JavaDoc {
735         throw new SQLException JavaDoc("updateNull");
736     }
737     
738     /**
739      * @see java.sql.ResultSet
740      *
741      * @exception SQLException on unexpected JDBC error
742      */

743     public void updateBoolean(int columnIndex, boolean x)
744     throws SQLException JavaDoc {
745         throw new SQLException JavaDoc("updateBoolean");
746     }
747     
748     /**
749      * @see java.sql.ResultSet
750      *
751      * @exception SQLException on unexpected JDBC error
752      */

753     public void updateByte(int columnIndex, byte x)
754     throws SQLException JavaDoc {
755         throw new SQLException JavaDoc("updateByte");
756     }
757     
758     /**
759      * @see java.sql.ResultSet
760      *
761      * @exception SQLException on unexpected JDBC error
762      */

763     public void updateShort(int columnIndex, short x)
764     throws SQLException JavaDoc {
765         throw new SQLException JavaDoc("updateShort");
766     }
767     
768     /**
769      * @see java.sql.ResultSet
770      *
771      * @exception SQLException on unexpected JDBC error
772      */

773     public void updateInt(int columnIndex, int x)
774     throws SQLException JavaDoc {
775         throw new SQLException JavaDoc("updateInt");
776     }
777     
778     /**
779      * @see java.sql.ResultSet
780      *
781      * @exception SQLException on unexpected JDBC error
782      */

783     public void updateLong(int columnIndex, long x)
784     throws SQLException JavaDoc {
785         throw new SQLException JavaDoc("updateLong");
786     }
787     
788     /**
789      * @see java.sql.ResultSet
790      *
791      * @exception SQLException on unexpected JDBC error
792      */

793     public void updateFloat(int columnIndex, float x)
794     throws SQLException JavaDoc {
795         throw new SQLException JavaDoc("updateFloat");
796     }
797     
798     /**
799      * @see java.sql.ResultSet
800      *
801      * @exception SQLException on unexpected JDBC error
802      */

803     public void updateDouble(int columnIndex, double x)
804     throws SQLException JavaDoc {
805         throw new SQLException JavaDoc("updateDouble");
806     }
807     
808     /**
809      * @see java.sql.ResultSet
810      *
811      * @exception SQLException on unexpected JDBC error
812      */

813     public void updateBigDecimal(int columnIndex, BigDecimal JavaDoc x)
814     throws SQLException JavaDoc {
815         throw new SQLException JavaDoc("updateBigDecimal");
816     }
817     
818     /**
819      * @see java.sql.ResultSet
820      *
821      * @exception SQLException on unexpected JDBC error
822      */

823     public void updateString(int columnIndex, String JavaDoc x)
824     throws SQLException JavaDoc {
825         throw new SQLException JavaDoc("updateString");
826     }
827     
828     /**
829      * @see java.sql.ResultSet
830      *
831      * @exception SQLException on unexpected JDBC error
832      */

833     public void updateBytes(int columnIndex, byte[] x)
834     throws SQLException JavaDoc {
835         throw new SQLException JavaDoc("updateBytes");
836     }
837     
838     /**
839      * @see java.sql.ResultSet
840      *
841      * @exception SQLException on unexpected JDBC error
842      */

843     public void updateDate(int columnIndex, java.sql.Date JavaDoc x)
844     throws SQLException JavaDoc {
845         throw new SQLException JavaDoc("updateDate");
846     }
847     
848     /**
849      * @see java.sql.ResultSet
850      *
851      * @exception SQLException on unexpected JDBC error
852      */

853     public void updateTime(int columnIndex, java.sql.Time JavaDoc x)
854     throws SQLException JavaDoc {
855         throw new SQLException JavaDoc("updateTime");
856     }
857     
858     /**
859      * @see java.sql.ResultSet
860      *
861      * @exception SQLException on unexpected JDBC error
862      */

863     public void updateTimestamp(int columnIndex, java.sql.Timestamp JavaDoc x)
864     throws SQLException JavaDoc {
865         throw new SQLException JavaDoc("updateTimestamp");
866     }
867     
868     /**
869      * @see java.sql.ResultSet
870      *
871      * @exception SQLException on unexpected JDBC error
872      */

873     public void updateAsciiStream(int columnIndex,
874             java.io.InputStream JavaDoc x,
875             int length)
876     throws SQLException JavaDoc {
877         throw new SQLException JavaDoc("updateAsciiStream");
878     }
879     
880     /**
881      * @see java.sql.ResultSet
882      *
883      * @exception SQLException on unexpected JDBC error
884      */

885     public void updateBinaryStream(int columnIndex,
886             java.io.InputStream JavaDoc x,
887             int length)
888     throws SQLException JavaDoc {
889         throw new SQLException JavaDoc("updateBinaryStream");
890     }
891     
892     /**
893      * @see java.sql.ResultSet
894      *
895      * @exception SQLException on unexpected JDBC error
896      */

897     public void updateCharacterStream(int columnIndex,
898             java.io.Reader JavaDoc x,
899             int length)
900     throws SQLException JavaDoc {
901         throw new SQLException JavaDoc("updateCharacterStream");
902     }
903     
904     /**
905      * @see java.sql.ResultSet
906      *
907      * @exception SQLException on unexpected JDBC error
908      */

909     public void updateObject(int columnIndex,
910             Object JavaDoc x,
911             int scale)
912     throws SQLException JavaDoc {
913         throw new SQLException JavaDoc("updateObject");
914     }
915     
916     /**
917      * @see java.sql.ResultSet
918      *
919      * @exception SQLException on unexpected JDBC error
920      */

921     public void updateObject(int columnIndex, Object JavaDoc x)
922     throws SQLException JavaDoc {
923         throw new SQLException JavaDoc("updateObject");
924     }
925     
926     /**
927      * @see java.sql.ResultSet
928      *
929      * @exception SQLException on unexpected JDBC error
930      */

931     public void updateNull(String JavaDoc columnName)
932     throws SQLException JavaDoc {
933         throw new SQLException JavaDoc("updateNull");
934     }
935     
936     /**
937      * @see java.sql.ResultSet
938      *
939      * @exception SQLException on unexpected JDBC error
940      */

941     public void updateBoolean(String JavaDoc columnName, boolean x)
942     throws SQLException JavaDoc {
943         throw new SQLException JavaDoc("updateBoolean");
944     }
945     
946     /**
947      * @see java.sql.ResultSet
948      *
949      * @exception SQLException on unexpected JDBC error
950      */

951     public void updateByte(String JavaDoc columnName, byte x)
952     throws SQLException JavaDoc {
953         throw new SQLException JavaDoc("updateByte");
954     }
955     
956     /**
957      * @see java.sql.ResultSet
958      *
959      * @exception SQLException on unexpected JDBC error
960      */

961     public void updateShort(String JavaDoc columnName, short x)
962     throws SQLException JavaDoc {
963         throw new SQLException JavaDoc("updateShort");
964     }
965     
966     /**
967      * @see java.sql.ResultSet
968      *
969      * @exception SQLException on unexpected JDBC error
970      */

971     public void updateInt(String JavaDoc columnName, int x)
972     throws SQLException JavaDoc {
973         throw new SQLException JavaDoc("updateInt");
974     }
975     
976     /**
977      * @see java.sql.ResultSet
978      *
979      * @exception SQLException on unexpected JDBC error
980      */

981     public void updateLong(String JavaDoc columnName, long x)
982     throws SQLException JavaDoc {
983         throw new SQLException JavaDoc("updateLong");
984     }
985     
986     /**
987      * @see java.sql.ResultSet
988      *
989      * @exception SQLException on unexpected JDBC error
990      */

991     public void updateFloat(String JavaDoc columnName, float x)
992     throws SQLException JavaDoc {
993         throw new SQLException JavaDoc("updateFloat");
994     }
995     
996     /**
997      * @see java.sql.ResultSet
998      *
999      * @exception SQLException on unexpected JDBC error
1000     */

1001    public void updateDouble(String JavaDoc columnName, double x)
1002    throws SQLException JavaDoc {
1003        throw new SQLException JavaDoc("updateDouble");
1004    }
1005    
1006    /**
1007     * @see java.sql.ResultSet
1008     *
1009     * @exception SQLException on unexpected JDBC error
1010     */

1011    public void updateBigDecimal(String JavaDoc columnName, BigDecimal JavaDoc x)
1012    throws SQLException JavaDoc {
1013        throw new SQLException JavaDoc("updateBigDecimal");
1014    }
1015    
1016    /**
1017     * @see java.sql.ResultSet
1018     *
1019     * @exception SQLException on unexpected JDBC error
1020     */

1021    public void updateString(String JavaDoc columnName, String JavaDoc x)
1022    throws SQLException JavaDoc {
1023        throw new SQLException JavaDoc("updateString");
1024    }
1025    
1026    /**
1027     * @see java.sql.ResultSet
1028     *
1029     * @exception SQLException on unexpected JDBC error
1030     */

1031    public void updateBytes(String JavaDoc columnName, byte[] x)
1032    throws SQLException JavaDoc {
1033        throw new SQLException JavaDoc("updateBytes");
1034    }
1035    
1036    /**
1037     * @see java.sql.ResultSet
1038     *
1039     * @exception SQLException on unexpected JDBC error
1040     */

1041    public void updateDate(String JavaDoc columnName, java.sql.Date JavaDoc x)
1042    throws SQLException JavaDoc {
1043        throw new SQLException JavaDoc("updateDate");
1044    }
1045    
1046    /**
1047     * @see java.sql.ResultSet
1048     *
1049     * @exception SQLException on unexpected JDBC error
1050     */

1051    public void updateTime(String JavaDoc columnName, java.sql.Time JavaDoc x)
1052    throws SQLException JavaDoc {
1053        throw new SQLException JavaDoc("updateTime");
1054    }
1055    
1056    /**
1057     * @see java.sql.ResultSet
1058     *
1059     * @exception SQLException on unexpected JDBC error
1060     */

1061    public void updateTimestamp(String JavaDoc columnName, java.sql.Timestamp JavaDoc x)
1062    throws SQLException JavaDoc {
1063        throw new SQLException JavaDoc("updateTimestamp");
1064    }
1065    
1066    /**
1067     * @see java.sql.ResultSet
1068     *
1069     * @exception SQLException on unexpected JDBC error
1070     */

1071    public void updateAsciiStream(String JavaDoc columnName,
1072            java.io.InputStream JavaDoc x,
1073            int length)
1074    throws SQLException JavaDoc {
1075        throw new SQLException JavaDoc("updateAsciiStream");
1076    }
1077    
1078    /**
1079     * @see java.sql.ResultSet
1080     *
1081     * @exception SQLException on unexpected JDBC error
1082     */

1083    public void updateBinaryStream(String JavaDoc columnName,
1084            java.io.InputStream JavaDoc x,
1085            int length)
1086    throws SQLException JavaDoc {
1087        throw new SQLException JavaDoc("updateBinaryStream");
1088    }
1089    
1090    /**
1091     * @see java.sql.ResultSet
1092     *
1093     * @exception SQLException on unexpected JDBC error
1094     */

1095    public void updateCharacterStream(String JavaDoc columnName,
1096            java.io.Reader JavaDoc x,
1097            int length)
1098    throws SQLException JavaDoc {
1099        throw new SQLException JavaDoc("updateCharacterStream");
1100    }
1101    
1102    /**
1103     * @see java.sql.ResultSet
1104     *
1105     * @exception SQLException on unexpected JDBC error
1106     */

1107    public void updateObject(String JavaDoc columnName,
1108            Object JavaDoc x,
1109            int scale)
1110    throws SQLException JavaDoc {
1111        throw new SQLException JavaDoc("updateObject");
1112    }
1113    
1114    /**
1115     * @see java.sql.ResultSet
1116     *
1117     * @exception SQLException on unexpected JDBC error
1118     */

1119    public void updateObject(String JavaDoc columnName, Object JavaDoc x)
1120    throws SQLException JavaDoc {
1121        throw new SQLException JavaDoc("updateObject");
1122    }
1123    
1124    /**
1125     * @see java.sql.ResultSet
1126     *
1127     * @exception SQLException on unexpected JDBC error
1128     */

1129    public void insertRow()
1130    throws SQLException JavaDoc {
1131        throw new SQLException JavaDoc("insertRow");
1132    }
1133    
1134    /**
1135     * @see java.sql.ResultSet
1136     *
1137     * @exception SQLException on unexpected JDBC error
1138     */

1139    public void updateRow()
1140    throws SQLException JavaDoc {
1141        throw new SQLException JavaDoc("updateRow");
1142    }
1143    
1144    /**
1145     * @see java.sql.ResultSet
1146     *
1147     * @exception SQLException on unexpected JDBC error
1148     */

1149    public void deleteRow()
1150    throws SQLException JavaDoc {
1151        throw new SQLException JavaDoc("deleteRow");
1152    }
1153    
1154    /**
1155     * @see java.sql.ResultSet
1156     *
1157     * @exception SQLException on unexpected JDBC error
1158     */

1159    public void refreshRow()
1160    throws SQLException JavaDoc {
1161        throw new SQLException JavaDoc("refreshRow");
1162    }
1163    
1164    /**
1165     * @see java.sql.ResultSet
1166     *
1167     * @exception SQLException on unexpected JDBC error
1168     */

1169    public void cancelRowUpdates()
1170    throws SQLException JavaDoc {
1171        throw new SQLException JavaDoc("cancelRowUpdates");
1172    }
1173    
1174    /**
1175     * @see java.sql.ResultSet
1176     *
1177     * @exception SQLException on unexpected JDBC error
1178     */

1179    public void moveToInsertRow()
1180    throws SQLException JavaDoc {
1181        throw new SQLException JavaDoc("moveToInsertRow");
1182    }
1183    
1184    /**
1185     * @see java.sql.ResultSet
1186     *
1187     * @exception SQLException on unexpected JDBC error
1188     */

1189    public void moveToCurrentRow()
1190    throws SQLException JavaDoc {
1191        throw new SQLException JavaDoc("moveToCurrentRow");
1192    }
1193    
1194    /**
1195     * @see java.sql.ResultSet
1196     *
1197     * @exception SQLException on unexpected JDBC error
1198     */

1199    public Statement JavaDoc getStatement()
1200    throws SQLException JavaDoc {
1201        throw new SQLException JavaDoc("getStatement");
1202    }
1203    /**
1204     * @see java.sql.ResultSet
1205     *
1206     * @exception SQLException on unexpected JDBC error
1207     */

1208    public java.sql.Date JavaDoc getDate(int columnIndex, Calendar JavaDoc cal)
1209    throws SQLException JavaDoc {
1210        throw new SQLException JavaDoc("getDate");
1211    }
1212    
1213    /**
1214     * @see java.sql.ResultSet
1215     *
1216     * @exception SQLException on unexpected JDBC error
1217     */

1218    public java.sql.Date JavaDoc getDate(String JavaDoc columnName, Calendar JavaDoc cal)
1219    throws SQLException JavaDoc {
1220        throw new SQLException JavaDoc("getDate");
1221    }
1222    
1223    /**
1224     * @see java.sql.ResultSet
1225     *
1226     * @exception SQLException on unexpected JDBC error
1227     */

1228    public java.sql.Time JavaDoc getTime(int columnIndex, Calendar JavaDoc cal)
1229    throws SQLException JavaDoc {
1230        throw new SQLException JavaDoc("getTime");
1231    }
1232    
1233    /**
1234     * @see java.sql.ResultSet
1235     *
1236     * @exception SQLException on unexpected JDBC error
1237     */

1238    public java.sql.Time JavaDoc getTime(String JavaDoc columnName, Calendar JavaDoc cal)
1239    throws SQLException JavaDoc {
1240        throw new SQLException JavaDoc("getTime");
1241    }
1242    
1243    /**
1244     * @see java.sql.ResultSet
1245     *
1246     * @exception SQLException on unexpected JDBC error
1247     */

1248    public java.sql.Timestamp JavaDoc getTimestamp(int columnIndex, Calendar JavaDoc cal)
1249    throws SQLException JavaDoc {
1250        throw new SQLException JavaDoc("getTimestamp");
1251    }
1252    
1253    /**
1254     * @see java.sql.ResultSet
1255     *
1256     * @exception SQLException on unexpected JDBC error
1257     */

1258    public java.sql.Timestamp JavaDoc getTimestamp(String JavaDoc columnName, Calendar JavaDoc cal)
1259    throws SQLException JavaDoc {
1260        throw new SQLException JavaDoc("getTimestamp");
1261    }
1262    /*
1263     ** JDBC 3.0 methods
1264     */

1265    
1266    /**
1267     * @see java.sql.ResultSet
1268     *
1269     * @exception SQLException on unexpected JDBC error
1270     */

1271    public URL JavaDoc getURL(int columnIndex)
1272    throws SQLException JavaDoc
1273    {
1274        throw new SQLException JavaDoc("getURL");
1275    }
1276    
1277    /**
1278     * @see java.sql.ResultSet
1279     *
1280     * @exception SQLException on unexpected JDBC error
1281     */

1282    public URL JavaDoc getURL(String JavaDoc columnName)
1283    throws SQLException JavaDoc {
1284        throw new SQLException JavaDoc("getURL");
1285    }
1286    
1287    /**
1288     * @see java.sql.ResultSet
1289     *
1290     * @exception SQLException on unexpected JDBC error
1291     */

1292    public Object JavaDoc getObject(int i, java.util.Map JavaDoc map)
1293    throws SQLException JavaDoc {
1294        throw new SQLException JavaDoc("getObject");
1295    }
1296    
1297    /**
1298     * @see java.sql.ResultSet
1299     *
1300     * @exception SQLException on unexpected JDBC error
1301     */

1302    public Ref JavaDoc getRef(int i)
1303    throws SQLException JavaDoc {
1304        throw new SQLException JavaDoc("getRef");
1305    }
1306    
1307    /**
1308     * @see java.sql.ResultSet
1309     *
1310     * @exception SQLException on unexpected JDBC error
1311     */

1312    public Blob JavaDoc getBlob(int i)
1313    throws SQLException JavaDoc {
1314        throw new SQLException JavaDoc("getBlob");
1315    }
1316    
1317    /**
1318     * @see java.sql.ResultSet
1319     *
1320     * @exception SQLException on unexpected JDBC error
1321     */

1322    public Clob JavaDoc getClob(int i)
1323    throws SQLException JavaDoc {
1324        throw new SQLException JavaDoc("getClob");
1325    }
1326    
1327    /**
1328     * @see java.sql.ResultSet
1329     *
1330     * @exception SQLException on unexpected JDBC error
1331     */

1332    public Array JavaDoc getArray(int i)
1333    throws SQLException JavaDoc {
1334        throw new SQLException JavaDoc("getArray");
1335    }
1336    
1337    /**
1338     * @see java.sql.ResultSet
1339     *
1340     * @exception SQLException on unexpected JDBC error
1341     */

1342    public Object JavaDoc getObject(String JavaDoc colName, java.util.Map JavaDoc map)
1343    throws SQLException JavaDoc {
1344        throw new SQLException JavaDoc("getObject");
1345    }
1346    
1347    /**
1348     * @see java.sql.ResultSet
1349     *
1350     * @exception SQLException on unexpected JDBC error
1351     */

1352    public Ref JavaDoc getRef(String JavaDoc colName)
1353    throws SQLException JavaDoc {
1354        throw new SQLException JavaDoc("getRef");
1355    }
1356    
1357    /**
1358     * @see java.sql.ResultSet
1359     *
1360     * @exception SQLException on unexpected JDBC error
1361     */

1362    public Blob JavaDoc getBlob(String JavaDoc colName)
1363    throws SQLException JavaDoc {
1364        throw new SQLException JavaDoc("getBlob");
1365    }
1366    
1367    /**
1368     * @see java.sql.ResultSet
1369     *
1370     * @exception SQLException on unexpected JDBC error
1371     */

1372    public Clob JavaDoc getClob(String JavaDoc colName)
1373    throws SQLException JavaDoc {
1374        throw new SQLException JavaDoc("getClob");
1375    }
1376    
1377    /**
1378     * @see java.sql.ResultSet
1379     *
1380     * @exception SQLException on unexpected JDBC error
1381     */

1382    public Array JavaDoc getArray(String JavaDoc colName)
1383    throws SQLException JavaDoc {
1384        throw new SQLException JavaDoc("getArray");
1385    }
1386    
1387    
1388    // JDBC 3.0 methods - not implemented
1389

1390    /**
1391     * @see java.sql.ResultSet
1392     *
1393     * @exception SQLException on unexpected JDBC error
1394     */

1395    public void updateRef(int columnIndex, Ref JavaDoc x)
1396    throws SQLException JavaDoc {
1397        throw new SQLException JavaDoc("updateRef");
1398    }
1399    
1400    /**
1401     * @see java.sql.ResultSet
1402     *
1403     * @exception SQLException on unexpected JDBC error
1404     */

1405    public void updateRef(String JavaDoc columnName, Ref JavaDoc x)
1406    throws SQLException JavaDoc {
1407        throw new SQLException JavaDoc("updateRef");
1408    }
1409    
1410    /**
1411     * @see java.sql.ResultSet
1412     *
1413     * @exception SQLException on unexpected JDBC error
1414     */

1415    public void updateBlob(int columnIndex, Blob JavaDoc x)
1416    throws SQLException JavaDoc {
1417        throw new SQLException JavaDoc("updateBlob");
1418    }
1419    
1420    /**
1421     * @see java.sql.ResultSet
1422     *
1423     * @exception SQLException on unexpected JDBC error
1424     */

1425    public void updateBlob(String JavaDoc columnName, Blob JavaDoc x)
1426    throws SQLException JavaDoc {
1427        throw new SQLException JavaDoc("updateBlob");
1428    }
1429    
1430    /**
1431     * @see java.sql.ResultSet
1432     *
1433     * @exception SQLException on unexpected JDBC error
1434     */

1435    public void updateClob(int columnIndex, Clob JavaDoc x)
1436    throws SQLException JavaDoc {
1437        throw new SQLException JavaDoc("updateClob");
1438    }
1439    
1440    /**
1441     * @see java.sql.ResultSet
1442     *
1443     * @exception SQLException on unexpected JDBC error
1444     */

1445    public void updateClob(String JavaDoc columnName, Clob JavaDoc x)
1446    throws SQLException JavaDoc {
1447        throw new SQLException JavaDoc("updateClob");
1448    }
1449    
1450    /**
1451     * @see java.sql.ResultSet
1452     *
1453     * @exception SQLException on unexpected JDBC error
1454     */

1455    public void updateArray(int columnIndex, Array JavaDoc x)
1456    throws SQLException JavaDoc {
1457        throw new SQLException JavaDoc("updateArray");
1458    }
1459    
1460    /**
1461     * @see java.sql.ResultSet
1462     *
1463     * @exception SQLException on unexpected JDBC error
1464     */

1465    public void updateArray(String JavaDoc columnName, Array JavaDoc x)
1466    throws SQLException JavaDoc {
1467        throw new SQLException JavaDoc("updateArray");
1468    }
1469}
1470
Popular Tags