KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > javax > sql > rowset > serial > SerialArray


1 /*
2  * @(#)SerialArray.java 1.9 04/05/29
3  *
4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */

7
8 package javax.sql.rowset.serial;
9
10 import java.sql.*;
11 import java.io.*;
12 import java.util.Map JavaDoc;
13 import java.net.URL JavaDoc;
14
15
16 /**
17  * A serialized version of an <code>Array</code>
18  * object, which is the mapping in the Java programming language of an SQL
19  * <code>ARRAY</code> value.
20  * <P>
21  * The <code>SerialArray</code> class provides a constructor for creating
22  * a <code>SerialArray</code> instance from an <code>Array</code> object,
23  * methods for getting the base type and the SQL name for the base type, and
24  * methods for copying all or part of a <code>SerialArray</code> object.
25  * <P>
26  * Note: In order for this class to function correctly, a connection to the
27  * data source
28  * must be available in order for the SQL <code>Array</code> object to be
29  * materialized (have all of its elements brought to the client server)
30  * if necessary. At this time, logical pointers to the data in the data source,
31  * such as locators, are not currently supported.
32  */

33 public class SerialArray implements Array, Serializable, Cloneable JavaDoc {
34
35     /**
36      * A serialized array in which each element is an <code>Object</code>
37      * in the Java programming language that represents an element
38      * in the SQL <code>ARRAY</code> value.
39      * @serial
40      */

41     private Object JavaDoc[] elements;
42
43     /**
44      * The SQL type of the elements in this <code>SerialArray</code> object. The
45      * type is expressed as one of the constants from the class
46      * <code>java.sql.Types</code>.
47      * @serial
48      */

49     private int baseType;
50
51     /**
52      * The type name used by the DBMS for the elements in the SQL <code>ARRAY</code>
53      * value that this <code>SerialArray</code> object represents.
54      * @serial
55      */

56     private String JavaDoc baseTypeName;
57
58     /**
59      * The number of elements in this <code>SerialArray</code> object, which
60      * is also the number of elements in the SQL <code>ARRAY</code> value
61      * that this <code>SerialArray</code> object represents.
62      * @serial
63      */

64     private int len;
65     
66     /**
67      * Constructs a new <code>SerialArray</code> object from the given
68      * <code>Array</code> object, using the given type map for the custom
69      * mapping of each element when the elements are SQL UDTs.
70      * <P>
71      * This method does custom mapping if the array elements are a UDT
72      * and the given type map has an entry for that UDT.
73      * Custom mapping is recursive,
74      * meaning that if, for instance, an element of an SQL structured type
75      * is an SQL structured type that itself has an element that is an SQL
76      * structured type, each structured type that has a custom mapping will be
77      * mapped according to the given type map.
78      * <P>
79      * The new <code>SerialArray</code>
80      * object contains the same elements as the <code>Array</code> object
81      * from which it is built, except when the base type is the SQL type
82      * <code>STRUCT</code>, <code>ARRAY</code>, <code>BLOB</code>,
83      * <code>CLOB</code>, <code>DATALINK</code> or <code>JAVA_OBJECT</code>.
84      * In this case, each element in the new
85      * <code>SerialArray</code> object is the appropriate serialized form,
86      * that is, a <code>SerialStruct</code>, <code>SerialArray</code>,
87      * <code>SerialBlob</code>, <code>SerialClob</code>,
88      * <code>SerialDatalink</code>, or <code>SerialJavaObject</code> object.
89      * <P>
90      * Note: (1) The <code>Array</code> object from which a <code>SerialArray</code>
91      * object is created must have materialized the SQL <code>ARRAY</code> value's
92      * data on the client before it is passed to the constructor. Otherwise,
93      * the new <code>SerialArray</code> object will contain no data.
94      * <p>
95      * Note: (2) If the <code>Array</code> contains <code>java.sql.Types.JAVA_OBJECT</code>
96      * types, the <code>SerialJavaObject</code> constructor is called where checks
97      * are made to ensure this object is serializable.
98      * <p>
99      * Note: (3) The <code>Array</code> object supplied to this constructor cannot
100      * return <code>null</code> for any <code>Array.getArray()</code> methods.
101      * <code>SerialArray</code> cannot serialize null array values.
102      *
103      *
104      * @param array the <code>Array</code> object to be serialized
105      * @param map a <code>java.util.Map</code> object in which
106      * each entry consists of 1) a <code>String</code> object
107      * giving the fully qualified name of a UDT (an SQL structured type or
108      * distinct type) and 2) the
109      * <code>Class</code> object for the <code>SQLData</code> implementation
110      * that defines how the UDT is to be mapped. The <i>map</i>
111      * parameter does not have any effect for <code>Blob</code>,
112      * <code>Clob</code>, <code>DATALINK</code>, or
113      * <code>JAVA_OBJECT</code> types.
114      * @throws SerialException if an error occurs serializing the
115      * <code>Array</code> object
116      * @throws SQLException if a database access error occurs or if the
117      * <i>array</i> or the <i>map</i> values are <code>null</code>
118      */

119      public SerialArray(Array array, Map JavaDoc<String JavaDoc,Class JavaDoc<?>> map)
120          throws SerialException JavaDoc, SQLException
121      {
122          
123         if ((array == null) || (map == null)) {
124             throw new SQLException("Cannot instantiate a SerialArray " +
125             "object with null parameters");
126         }
127                  
128         if ((elements = (Object JavaDoc[])array.getArray()) == null) {
129              throw new SQLException("Invalid Array object. Calls to Array.getArray() " +
130                  "return null value which cannot be serialized");
131          }
132
133     elements = (Object JavaDoc[])array.getArray(map);
134         baseType = array.getBaseType();
135         baseTypeName = array.getBaseTypeName();
136         len = elements.length;
137
138         switch (baseType) {
139             case java.sql.Types.STRUCT:
140                 for (int i = 0; i < len; i++) {
141                     elements[i] = new SerialStruct JavaDoc((Struct)elements[i], map);
142                 }
143             break;
144         
145             case java.sql.Types.ARRAY:
146                 for (int i = 0; i < len; i++) {
147                     elements[i] = new SerialArray JavaDoc((Array)elements[i], map);
148                 }
149             break;
150         
151             case java.sql.Types.BLOB:
152             for (int i = 0; i < len; i++) {
153                 elements[i] = new SerialBlob JavaDoc((Blob)elements[i]);
154             }
155             break;
156        
157             case java.sql.Types.CLOB:
158                 for (int i = 0; i < len; i++) {
159                     elements[i] = new SerialClob JavaDoc((Clob)elements[i]);
160                 }
161             break;
162
163             case java.sql.Types.DATALINK:
164                 for (int i = 0; i < len; i++) {
165                     elements[i] = new SerialDatalink JavaDoc((URL JavaDoc)elements[i]);
166                 }
167             break;
168             
169             case java.sql.Types.JAVA_OBJECT:
170                 for (int i = 0; i < len; i++) {
171             elements[i] = new SerialJavaObject JavaDoc((Object JavaDoc)elements[i]);
172             }
173         default:
174             ;
175         }
176   }
177      
178      
179      
180     /**
181      * Constructs a new <code>SerialArray</code> object from the given
182      * <code>Array</code> object.
183      * <P>
184      * This constructor does not do custom mapping. If the base type of the array
185      * is an SQL structured type and custom mapping is desired, the constructor
186      * <code>SerialArray(Array array, Map map)</code> should be used.
187      * <P>
188      * The new <code>SerialArray</code>
189      * object contains the same elements as the <code>Array</code> object
190      * from which it is built, except when the base type is the SQL type
191      * <code>BLOB</code>,
192      * <code>CLOB</code>, <code>DATALINK</code> or <code>JAVA_OBJECT</code>.
193      * In this case, each element in the new
194      * <code>SerialArray</code> object is the appropriate serialized form,
195      * that is, a <code>SerialBlob</code>, <code>SerialClob</code>,
196      * <code>SerialDatalink</code>, or <code>SerialJavaObject</code> object.
197      * <P>
198      * Note: (1) The <code>Array</code> object from which a <code>SerialArray</code>
199      * object is created must have materialized the SQL <code>ARRAY</code> value's
200      * data on the client before it is passed to the constructor. Otherwise,
201      * the new <code>SerialArray</code> object will contain no data.
202      * <p>
203      * Note: (2) The <code>Array</code> object supplied to this constructor cannot
204      * return <code>null</code> for any <code>Array.getArray()</code> methods.
205      * <code>SerialArray</code> cannot serialize <code>null</code> array values.
206      *
207      * @param array the <code>Array</code> object to be serialized
208      * @throws SerialException if an error occurs serializing the
209      * <code>Array</code> object
210      * @throws SQLException if a database access error occurs or the
211      * <i>array</i> parameter is <code>null</code>.
212      */

213      public SerialArray(Array array) throws SerialException JavaDoc, SQLException {
214          if (array == null) {
215              throw new SQLException("Cannot instantiate a SerialArray " +
216                  "object with a null Array object");
217          }
218          
219          if ((elements = (Object JavaDoc[])array.getArray()) == null) {
220              throw new SQLException("Invalid Array object. Calls to Array.getArray() " +
221                  "return null value which cannot be serialized");
222          }
223          
224          //elements = (Object[])array.getArray();
225
baseType = array.getBaseType();
226          baseTypeName = array.getBaseTypeName();
227          len = elements.length;
228
229         switch (baseType) {
230
231         case java.sql.Types.BLOB:
232             for (int i = 0; i < len; i++) {
233                 elements[i] = new SerialBlob JavaDoc((Blob)elements[i]);
234             }
235             break;
236             
237         case java.sql.Types.CLOB:
238             for (int i = 0; i < len; i++) {
239                 elements[i] = new SerialClob JavaDoc((Clob)elements[i]);
240             }
241             break;
242             
243     case java.sql.Types.DATALINK:
244         for (int i = 0; i < len; i++) {
245         elements[i] = new SerialDatalink JavaDoc((URL JavaDoc)elements[i]);
246         }
247             break;
248             
249     case java.sql.Types.JAVA_OBJECT:
250         for (int i = 0; i < len; i++) {
251         elements[i] = new SerialJavaObject JavaDoc((Object JavaDoc)elements[i]);
252         }
253             
254         default:
255             ;
256         }
257             
258             
259     }
260
261     /**
262      * Returns a new array that is a copy of this <code>SerialArray</code>
263      * object.
264      *
265      * @return a copy of this <code>SerialArray</code> object as an
266      * <code>Object</code> in the Java programming language
267      * @throws SerialException if an error occurs retrieving a copy of
268      * this <code>SerialArray</code> object
269      */

270     public Object JavaDoc getArray() throws SerialException JavaDoc {
271         Object JavaDoc dst = new Object JavaDoc[len];
272         System.arraycopy((Object JavaDoc)elements, 0, dst, 0, len);
273         return dst;
274     }
275
276  //[if an error occurstype map used??]
277
/**
278      * Returns a new array that is a copy of this <code>SerialArray</code>
279      * object, using the given type map for the custom
280      * mapping of each element when the elements are SQL UDTs.
281      * <P>
282      * This method does custom mapping if the array elements are a UDT
283      * and the given type map has an entry for that UDT.
284      * Custom mapping is recursive,
285      * meaning that if, for instance, an element of an SQL structured type
286      * is an SQL structured type that itself has an element that is an SQL
287      * structured type, each structured type that has a custom mapping will be
288      * mapped according to the given type map.
289      *
290      * @param map a <code>java.util.Map</code> object in which
291      * each entry consists of 1) a <code>String</code> object
292      * giving the fully qualified name of a UDT and 2) the
293      * <code>Class</code> object for the <code>SQLData</code> implementation
294      * that defines how the UDT is to be mapped
295      * @return a copy of this <code>SerialArray</code> object as an
296      * <code>Object</code> in the Java programming language
297      * @throws SerialException if an error occurs
298      */

299     public Object JavaDoc getArray(Map JavaDoc<String JavaDoc, Class JavaDoc<?>> map) throws SerialException JavaDoc {
300         Object JavaDoc dst[] = new Object JavaDoc[len];
301         System.arraycopy((Object JavaDoc)elements, 0, dst, 0, len);
302         return dst;
303     }
304     
305     /**
306      * Returns a new array that is a copy of a slice
307      * of this <code>SerialArray</code> object, starting with the
308      * element at the given index and containing the given number
309      * of consecutive elements.
310      *
311      * @param index the index into this <code>SerialArray</code> object
312      * of the first element to be copied;
313      * the index of the first element is <code>0</code>
314      * @param count the number of consecutive elements to be copied, starting
315      * at the given index
316      * @return a copy of the designated elements in this <code>SerialArray</code>
317      * object as an <code>Object</code> in the Java programming language
318      * @throws SerialException if an error occurs
319      */

320     public Object JavaDoc getArray(long index, int count) throws SerialException JavaDoc {
321         Object JavaDoc dst = new Object JavaDoc[count];
322         System.arraycopy((Object JavaDoc)elements, (int)index, dst, 0, count);
323         return dst;
324     }
325
326     /**
327      * Returns a new array that is a copy of a slice
328      * of this <code>SerialArray</code> object, starting with the
329      * element at the given index and containing the given number
330      * of consecutive elements.
331      * <P>
332      * This method does custom mapping if the array elements are a UDT
333      * and the given type map has an entry for that UDT.
334      * Custom mapping is recursive,
335      * meaning that if, for instance, an element of an SQL structured type
336      * is an SQL structured type that itself has an element that is an SQL
337      * structured type, each structured type that has a custom mapping will be
338      * mapped according to the given type map.
339      *
340      * @param index the index into this <code>SerialArray</code> object
341      * of the first element to be copied; the index of the
342      * first element in the array is <code>0</code>
343      * @param count the number of consecutive elements to be copied, starting
344      * at the given index
345      * @param map a <code>java.util.Map</code> object in which
346      * each entry consists of 1) a <code>String</code> object
347      * giving the fully qualified name of a UDT and 2) the
348      * <code>Class</code> object for the <code>SQLData</code> implementation
349      * that defines how the UDT is to be mapped
350      * @return a copy of the designated elements in this <code>SerialArray</code>
351      * object as an <code>Object</code> in the Java programming language
352      * @throws SerialException if an error occurs
353      */

354     public Object JavaDoc getArray(long index, int count, Map JavaDoc<String JavaDoc,Class JavaDoc<?>> map)
355         throws SerialException JavaDoc
356     {
357         Object JavaDoc dst = new Object JavaDoc[count];
358         System.arraycopy((Object JavaDoc)elements, (int)index, dst, 0, count);
359         return dst;
360     }
361
362     /**
363      * Retrieves the SQL type of the elements in this <code>SerialArray</code>
364      * object. The <code>int</code> returned is one of the constants in the class
365      * <code>java.sql.Types</code>.
366      *
367      * @return one of the constants in <code>java.sql.Types</code>, indicating
368      * the SQL type of the elements in this <code>SerialArray</code> object
369      * @throws SerialException if an error occurs
370      */

371     public int getBaseType() throws SerialException JavaDoc {
372         return baseType;
373     }
374     
375     /**
376      * Retrieves the DBMS-specific type name for the elements in this
377      * <code>SerialArray</code> object.
378      *
379      * @return the SQL type name used by the DBMS for the base type of this
380      * <code>SerialArray</code> object
381      * @throws SerialException if an error occurs
382      */

383     public String JavaDoc getBaseTypeName() throws SerialException JavaDoc {
384         return baseTypeName;
385     }
386         
387     /**
388      * Retrieves a <code>ResultSet</code> object holding the elements of
389      * the subarray that starts at
390      * index <i>index</i> and contains up to <i>count</i> successive elements.
391      * This method uses the connection's type map to map the elements of
392      * the array if the map contains
393      * an entry for the base type. Otherwise, the standard mapping is used.
394      *
395      * @param index the index into this <code>SerialArray</code> object
396      * of the first element to be copied; the index of the
397      * first element in the array is <code>0</code>
398      * @param count the number of consecutive elements to be copied, starting
399      * at the given index
400      * @return a <code>ResultSet</code> object containing the designated
401      * elements in this <code>SerialArray</code> object, with a
402      * separate row for each element
403      * @throws SerialException, which in turn throws an
404      * <code>UnsupportedOperationException</code>, if this method is called
405      */

406     public ResultSet getResultSet(long index, int count) throws SerialException JavaDoc {
407         throw new UnsupportedOperationException JavaDoc();
408     }
409
410     /**
411      *
412      * Retrieves a <code>ResultSet</code> object that contains all of
413      * the elements of the SQL <code>ARRAY</code>
414      * value represented by this <code>SerialArray</code> object. This method uses
415      * the specified map for type map customizations unless the base type of the
416      * array does not match a user-defined type (UDT) in <i>map</code>, in
417      * which case it uses the
418      * standard mapping. This version of the method <code>getResultSet</code>
419      * uses either the given type map or the standard mapping; it never uses the
420      * type map associated with the connection.
421      *
422      * @param map a <code>java.util.Map</code> object in which
423      * each entry consists of 1) a <code>String</code> object
424      * giving the fully qualified name of a UDT and 2) the
425      * <code>Class</code> object for the <code>SQLData</code> implementation
426      * that defines how the UDT is to be mapped
427      * @return a <code>ResultSet</code> object containing all of the
428      * elements in this <code>SerialArray</code> object, with a
429      * separate row for each element
430      * @throws SerialException, which in turn throws an
431      * <code>UnsupportedOperationException</code>, if this method is called
432      */

433     public ResultSet getResultSet(Map JavaDoc<String JavaDoc, Class JavaDoc<?>> map)
434         throws SerialException JavaDoc
435     {
436         throw new UnsupportedOperationException JavaDoc();
437     }
438     
439     /**
440      * Retrieves a <code>ResultSet</code> object that contains all of
441      * the elements in the <code>ARRAY</code> value that this
442      * <code>SerialArray</code> object represents.
443      * If appropriate, the elements of the array are mapped using the connection's
444      * type map; otherwise, the standard mapping is used.
445      *
446      * @return a <code>ResultSet</code> object containing all of the
447      * elements in this <code>SerialArray</code> object, with a
448      * separate row for each element
449      * @throws SerialException if called, which in turn throws an
450      * <code>UnsupportedOperationException</code>, if this method is called
451      */

452     public ResultSet getResultSet() throws SerialException JavaDoc {
453         throw new UnsupportedOperationException JavaDoc();
454     }
455
456     
457     /**
458      * Retrieves a result set holding the elements of the subarray that starts at
459      * Retrieves a <code>ResultSet</code> object that contains a subarray of the
460      * elements in this <code>SerialArray</code> object, starting at
461      * index <i>index</i> and containing up to <i>count</i> successive
462      * elements. This method uses
463      * the specified map for type map customizations unless the base type of the
464      * array does not match a user-defined type (UDT) in <i>map</i>, in
465      * which case it uses the
466      * standard mapping. This version of the method <code>getResultSet</code> uses
467      * either the given type map or the standard mapping; it never uses the type
468      * map associated with the connection.
469      *
470      * @param index the index into this <code>SerialArray</code> object
471      * of the first element to be copied; the index of the
472      * first element in the array is <code>0</code>
473      * @param count the number of consecutive elements to be copied, starting
474      * at the given index
475      * @param map a <code>java.util.Map</code> object in which
476      * each entry consists of 1) a <code>String</code> object
477      * giving the fully qualified name of a UDT and 2) the
478      * <code>Class</code> object for the <code>SQLData</code> implementation
479      * that defines how the UDT is to be mapped
480      * @return a <code>ResultSet</code> object containing the designated
481      * elements in this <code>SerialArray</code> object, with a
482      * separate row for each element
483      * @throws SerialException if called, which in turn throws an
484      * <code>UnsupportedOperationException</code>
485      */

486     public ResultSet getResultSet(long index, int count,
487                       Map JavaDoc<String JavaDoc,Class JavaDoc<?>> map)
488         throws SerialException JavaDoc
489     {
490         throw new UnsupportedOperationException JavaDoc();
491     }
492
493     /**
494      * Internal ResultSet implementation to serve getResultSet(XXX) methods.
495      *
496      * Suggest we return a READ_ONLY array to start. We can migrate to a updatable
497      * ResultSet later.
498      */

499     private class InternalResultSetImpl implements java.sql.ResultSet JavaDoc {
500         
501         /**
502          * Signature coverage for internal ResultSet implementation.
503          */

504         public boolean absolute(int row) throws SQLException {
505             return false;
506         }
507  
508         /**
509          * Signature coverage for internal ResultSet implementation.
510          */

511         public void afterLast() throws SQLException {
512         }
513         
514         /**
515          * Signature coverage for internal ResultSet implementation.
516          */

517         public void beforeFirst() throws SQLException {
518         }
519         /**
520          * Signature coverage for internal ResultSet implementation.
521          */

522         public void cancelRowUpdates() throws SQLException {
523         }
524         
525         /**
526          * Signature coverage for internal ResultSet implementation.
527          */

528         public void clearWarnings() throws SQLException {
529         }
530         
531         /**
532          * Signature coverage for internal ResultSet implementation.
533          */

534         public void close() throws SQLException {
535         }
536         
537         /**
538          * Signature coverage for internal ResultSet implementation.
539          */

540         public void deleteRow() throws SQLException {
541         }
542         
543         /**
544          * Signature coverage for internal ResultSet implementation.
545          */

546         public int findColumn(String JavaDoc columnName) throws SQLException {
547             return 0;
548         }
549         
550         /**
551          * Signature coverage for internal ResultSet implementation.
552          */

553         public boolean first() throws SQLException {
554             return false;
555         }
556         
557         /**
558          * Signature coverage for internal ResultSet implementation.
559          */

560         public Array getArray(int i) throws SQLException {
561             return null;
562         }
563         
564         /**
565          * Signature coverage for internal ResultSet implementation.
566          */

567         public Array getArray(String JavaDoc colName) throws SQLException {
568             return null;
569         }
570         
571         /**
572          * Signature coverage for internal ResultSet implementation.
573          */

574         public java.io.InputStream JavaDoc getAsciiStream(String JavaDoc columnName) throws SQLException {
575             return null;
576         }
577         
578         /**
579          * Signature coverage for internal ResultSet implementation.
580          */

581         public java.io.InputStream JavaDoc getAsciiStream(int columnIndex) throws SQLException {
582             return null;
583         }
584         
585         /**
586          * Signature coverage for internal ResultSet implementation.
587          */

588         public java.math.BigDecimal JavaDoc getBigDecimal(String JavaDoc columnName) throws SQLException {
589             return null;
590         }
591         
592         /**
593          * Signature coverage for internal ResultSet implementation.
594          */

595         public java.math.BigDecimal JavaDoc getBigDecimal(int columnIndex) throws SQLException {
596             return null;
597         }
598         
599         /**
600          * Signature coverage for internal ResultSet implementation.
601          */

602         public java.math.BigDecimal JavaDoc getBigDecimal(int columnIndex, int scale) throws SQLException {
603             return null;
604         }
605         
606         /**
607          * Signature coverage for internal ResultSet implementation.
608          */

609         public java.math.BigDecimal JavaDoc getBigDecimal(String JavaDoc columnName, int scale) throws SQLException {
610             return null;
611         }
612         
613         /**
614          * Signature coverage for internal ResultSet implementation.
615          */

616         public java.io.InputStream JavaDoc getBinaryStream(int columnIndex) throws SQLException {
617             return null;
618         }
619         
620         /**
621          * Signature coverage for internal ResultSet implementation.
622          */

623         public java.io.InputStream JavaDoc getBinaryStream(String JavaDoc columnName) throws SQLException {
624             return null;
625         }
626         
627         /**
628          * Signature coverage for internal ResultSet implementation.
629          */

630         public Blob getBlob(int i) throws SQLException {
631             return null;
632         }
633         
634         /**
635          * Signature coverage for internal ResultSet implementation.
636          */

637         public Blob getBlob(String JavaDoc colName) throws SQLException {
638             return null;
639         }
640         
641         /**
642          * Signature coverage for internal ResultSet implementation.
643          */

644         public boolean getBoolean(int columnIndex) throws SQLException {
645             return false;
646         }
647         
648         /**
649          * Signature coverage for internal ResultSet implementation.
650          */

651         public boolean getBoolean(String JavaDoc columnName) throws SQLException {
652             return false;
653         }
654         
655         /**
656          * Signature coverage for internal ResultSet implementation.
657          */

658         public byte getByte(int columnIndex) throws SQLException {
659             return 0;
660         }
661         
662         /**
663          * Signature coverage for internal ResultSet implementation.
664          */

665         public byte getByte(String JavaDoc columnName) throws SQLException {
666             return 0;
667         }
668         
669         /**
670          * Signature coverage for internal ResultSet implementation.
671          */

672         public byte[] getBytes(int columnIndex) throws SQLException {
673             return null;
674         }
675         
676         /**
677          * Signature coverage for internal ResultSet implementation.
678          */

679         public byte[] getBytes(String JavaDoc columnName) throws SQLException {
680             return null;
681         }
682         
683         /**
684          * Signature coverage for internal ResultSet implementation.
685          */

686         public java.io.Reader JavaDoc getCharacterStream(int columnIndex) throws SQLException {
687             return null;
688         }
689         
690         /**
691          * Signature coverage for internal ResultSet implementation.
692          */

693         public java.io.Reader JavaDoc getCharacterStream(String JavaDoc columnName) throws SQLException {
694             return null;
695         }
696         
697         /**
698          * Signature coverage for internal ResultSet implementation.
699          */

700         public Clob getClob(int i) throws SQLException {
701             return null;
702         }
703         
704         /**
705          * Signature coverage for internal ResultSet implementation.
706          */

707         public Clob getClob(String JavaDoc colName) throws SQLException {
708             return null;
709         }
710         
711         /**
712          * Signature coverage for internal ResultSet implementation.
713          */

714         public int getConcurrency() throws SQLException {
715             return 0;
716         }
717         
718         /**
719          * Signature coverage for internal ResultSet implementation.
720          */

721         public String JavaDoc getCursorName() throws SQLException {
722             return null;
723         }
724         
725         /**
726          * Signature coverage for internal ResultSet implementation.
727          */

728         public java.sql.Date JavaDoc getDate(int columnIndex) throws SQLException {
729             return null;
730         }
731         
732         /**
733          * Signature coverage for internal ResultSet implementation.
734          */

735         public java.sql.Date JavaDoc getDate(String JavaDoc columnName) throws SQLException {
736             return null;
737         }
738         
739         /**
740          * Signature coverage for internal ResultSet implementation.
741          */

742         public java.sql.Date JavaDoc getDate(int columnIndex, java.util.Calendar JavaDoc cal) throws SQLException {
743             return null;
744         }
745         
746         /**
747          * Signature coverage for internal ResultSet implementation.
748          */

749         public java.sql.Date JavaDoc getDate(String JavaDoc columnName, java.util.Calendar JavaDoc cal) throws SQLException {
750             return null;
751         }
752         
753         /**
754          * Signature coverage for internal ResultSet implementation.
755          */

756         public double getDouble(int columnIndex) throws SQLException {
757             return 0;
758         }
759         
760         /**
761          * Signature coverage for internal ResultSet implementation.
762          */

763         public double getDouble(String JavaDoc columnName) throws SQLException {
764             return 0;
765         }
766         
767         /**
768          * Signature coverage for internal ResultSet implementation.
769          */

770         public int getFetchDirection() throws SQLException {
771             return 0;
772         }
773         
774         /**
775          * Signature coverage for internal ResultSet implementation.
776          */

777         public int getFetchSize() throws SQLException {
778             return 0;
779         }
780         
781         /**
782          * Signature coverage for internal ResultSet implementation.
783          */

784         public float getFloat(int columnIndex) throws SQLException {
785             return 0;
786         }
787         
788         /**
789          * Signature coverage for internal ResultSet implementation.
790          */

791         public float getFloat(String JavaDoc columnName) throws SQLException {
792             return 0;
793         }
794         
795         /**
796          * Signature coverage for internal ResultSet implementation.
797          */

798         public int getInt(String JavaDoc columnName) throws SQLException {
799             return 0;
800         }
801         
802         /**
803          * Signature coverage for internal ResultSet implementation.
804          */

805         public int getInt(int columnIndex) throws SQLException {
806             return 0;
807         }
808         
809         /**
810          * Signature coverage for internal ResultSet implementation.
811          */

812         public long getLong(int columnIndex) throws SQLException {
813             return 0;
814         }
815         
816         /**
817          * Signature coverage for internal ResultSet implementation.
818          */

819         public long getLong(String JavaDoc columnName) throws SQLException {
820             return 0;
821         }
822         
823         /**
824          * Signature coverage for internal ResultSet implementation.
825          */

826         public ResultSetMetaData getMetaData() throws SQLException {
827             return null;
828         }
829         
830         /**
831          * Signature coverage for internal ResultSet implementation.
832          */

833         public Object JavaDoc getObject(int columnIndex) throws SQLException {
834             return null;
835         }
836         
837         /**
838          * Signature coverage for internal ResultSet implementation.
839          */

840         public Object JavaDoc getObject(String JavaDoc columnName) throws SQLException {
841             return null;
842         }
843         
844         /**
845          * Signature coverage for internal ResultSet implementation.
846          */

847         public Object JavaDoc getObject(int i, java.util.Map JavaDoc<String JavaDoc,Class JavaDoc<?>> map)
848             throws SQLException
849         {
850             return null;
851         }
852         
853         /**
854          * Signature coverage for internal ResultSet implementation.
855          */

856         public Object JavaDoc getObject(String JavaDoc colName, java.util.Map JavaDoc<String JavaDoc,Class JavaDoc<?>> map)
857             throws SQLException
858         {
859             return null;
860         }
861         
862         /**
863          * Signature coverage for internal ResultSet implementation.
864          */

865         public Ref getRef(int i) throws SQLException {
866             return null;
867         }
868         
869         /**
870          * Signature coverage for internal ResultSet implementation.
871          */

872         public Ref getRef(String JavaDoc colName) throws SQLException {
873             return null;
874         }
875         
876         /**
877          * Signature coverage for internal ResultSet implementation.
878          */

879         public int getRow() throws SQLException {
880             return 0;
881         }
882         
883         /**
884          * Signature coverage for internal ResultSet implementation.
885          */

886         public short getShort(String JavaDoc columnName) throws SQLException {
887             return 0;
888         }
889         
890         /**
891          * Signature coverage for internal ResultSet implementation.
892          */

893         public short getShort(int columnIndex) throws SQLException {
894             return 0;
895         }
896         
897         /**
898          * Signature coverage for internal ResultSet implementation.
899          */

900         public Statement getStatement() throws SQLException {
901             return null;
902         }
903         
904         /**
905          * Signature coverage for internal ResultSet implementation.
906          */

907         public String JavaDoc getString(String JavaDoc columnName) throws SQLException {
908             return null;
909         }
910         
911         /**
912          * Signature coverage for internal ResultSet implementation.
913          */

914         public String JavaDoc getString(int columnIndex) throws SQLException {
915             return null;
916         }
917         
918         /**
919          * Signature coverage for internal ResultSet implementation.
920          */

921         public java.sql.Time JavaDoc getTime(String JavaDoc columnName) throws SQLException {
922             return null;
923         }
924         
925         /**
926          * Signature coverage for internal ResultSet implementation.
927          */

928         public java.sql.Time JavaDoc getTime(int columnIndex) throws SQLException {
929             return null;
930         }
931         
932         /**
933          * Signature coverage for internal ResultSet implementation.
934          */

935         public java.sql.Time JavaDoc getTime(String JavaDoc columnName, java.util.Calendar JavaDoc cal) throws SQLException {
936             return null;
937         }
938         
939         /**
940          * Signature coverage for internal ResultSet implementation.
941          */

942         public java.sql.Time JavaDoc getTime(int columnIndex, java.util.Calendar JavaDoc cal) throws SQLException {
943             return null;
944         }
945         
946         /**
947          * Signature coverage for internal ResultSet implementation.
948          */

949         public java.sql.Timestamp JavaDoc getTimestamp(String JavaDoc columnName) throws SQLException {
950             return null;
951         }
952         
953         /**
954          * Signature coverage for internal ResultSet implementation.
955          */

956         public java.sql.Timestamp JavaDoc getTimestamp(int columnIndex) throws SQLException {
957             return null;
958         }
959         
960         /**
961          * Signature coverage for internal ResultSet implementation.
962          */

963         public java.sql.Timestamp JavaDoc getTimestamp(String JavaDoc columnName, java.util.Calendar JavaDoc cal) throws SQLException {
964             return null;
965         }
966         
967         /**
968          * Signature coverage for internal ResultSet implementation.
969          */

970         public java.sql.Timestamp JavaDoc getTimestamp(int columnIndex, java.util.Calendar JavaDoc cal) throws SQLException {
971             return null;
972         }
973         
974         /**
975          * Signature coverage for internal ResultSet implementation.
976          */

977         public int getType() throws SQLException {
978             return 0;
979         }
980         
981         /**
982          * Signature coverage for internal ResultSet implementation.
983          */

984         public java.net.URL JavaDoc getURL(int columnIndex) throws SQLException {
985             return null;
986         }
987         
988         /**
989          * Signature coverage for internal ResultSet implementation.
990          */

991         public java.net.URL JavaDoc getURL(String JavaDoc columnName) throws SQLException {
992             return null;
993         }
994         
995         /**
996          * Signature coverage for internal ResultSet implementation.
997          */

998         public java.io.InputStream JavaDoc getUnicodeStream(String JavaDoc columnName) throws SQLException {
999             return null;
1000        }
1001        
1002        /**
1003         * Signature coverage for internal ResultSet implementation.
1004         */

1005        public java.io.InputStream JavaDoc getUnicodeStream(int columnIndex) throws SQLException {
1006            return null;
1007        }
1008        
1009        /**
1010         * Signature coverage for internal ResultSet implementation.
1011         */

1012        public SQLWarning getWarnings() throws SQLException {
1013            return null;
1014        }
1015        
1016        /**
1017         * Signature coverage for internal ResultSet implementation.
1018         */

1019        public void insertRow() throws SQLException {
1020        }
1021        
1022        /**
1023         * Signature coverage for internal ResultSet implementation.
1024         */

1025        public boolean isAfterLast() throws SQLException {
1026            return false;
1027        }
1028        
1029        /**
1030         * Signature coverage for internal ResultSet implementation.
1031         */

1032        public boolean isBeforeFirst() throws SQLException {
1033            return false;
1034        }
1035        
1036        /**
1037         * Signature coverage for internal ResultSet implementation.
1038         */

1039        public boolean isFirst() throws SQLException {
1040            return false;
1041        }
1042        
1043        /**
1044         * Signature coverage for internal ResultSet implementation.
1045         */

1046        public boolean isLast() throws SQLException {
1047            return false;
1048        }
1049        
1050        /**
1051         * Signature coverage for internal ResultSet implementation.
1052         */

1053        public boolean last() throws SQLException {
1054            return false;
1055        }
1056        
1057        /**
1058         * Signature coverage for internal ResultSet implementation.
1059         */

1060        public void moveToCurrentRow() throws SQLException {
1061        }
1062        
1063        /**
1064         * Signature coverage for internal ResultSet implementation.
1065         */

1066        public void moveToInsertRow() throws SQLException {
1067        }
1068        
1069        /**
1070         * Signature coverage for internal ResultSet implementation.
1071         */

1072        public boolean next() throws SQLException {
1073            return false;
1074        }
1075        
1076        /**
1077         * Signature coverage for internal ResultSet implementation.
1078         */

1079        public boolean previous() throws SQLException {
1080            return false;
1081        }
1082        
1083        /**
1084         * Signature coverage for internal ResultSet implementation.
1085         */

1086        public void refreshRow() throws SQLException {
1087        }
1088        
1089        /**
1090         * Signature coverage for internal ResultSet implementation.
1091         */

1092        public boolean relative(int rows) throws SQLException {
1093            return false;
1094        }
1095        
1096        /**
1097         * Signature coverage for internal ResultSet implementation.
1098         */

1099        public boolean rowDeleted() throws SQLException {
1100            return false;
1101        }
1102        
1103        /**
1104         * Signature coverage for internal ResultSet implementation.
1105         */

1106        public boolean rowInserted() throws SQLException {
1107            return false;
1108        }
1109        
1110        /**
1111         * Signature coverage for internal ResultSet implementation.
1112         */

1113        public boolean rowUpdated() throws SQLException {
1114            return false;
1115        }
1116        
1117        /**
1118         * Signature coverage for internal ResultSet implementation.
1119         */

1120        public void setFetchDirection(int direction) throws SQLException {
1121        }
1122        
1123        /**
1124         * Signature coverage for internal ResultSet implementation.
1125         */

1126        public void setFetchSize(int rows) throws SQLException {
1127        }
1128        
1129        /**
1130         * Signature coverage for internal ResultSet implementation.
1131         */

1132        public void updateArray(String JavaDoc columnName, java.sql.Array JavaDoc x) throws SQLException {
1133        }
1134        
1135        /**
1136         * Signature coverage for internal ResultSet implementation.
1137         */

1138        public void updateArray(int columnIndex, java.sql.Array JavaDoc x) throws SQLException {
1139        }
1140        
1141        /**
1142         * Signature coverage for internal ResultSet implementation.
1143         */

1144        public void updateAsciiStream(String JavaDoc columnName, java.io.InputStream JavaDoc x, int length) throws SQLException {
1145        }
1146        
1147        /**
1148         * Signature coverage for internal ResultSet implementation.
1149         */

1150        public void updateAsciiStream(int columnIndex, java.io.InputStream JavaDoc x, int length) throws SQLException {
1151        }
1152        
1153        /**
1154         * Signature coverage for internal ResultSet implementation.
1155         */

1156        public void updateBigDecimal(String JavaDoc columnName, java.math.BigDecimal JavaDoc x) throws SQLException {
1157        }
1158        
1159        /**
1160         * Signature coverage for internal ResultSet implementation.
1161         */

1162        public void updateBigDecimal(int columnIndex, java.math.BigDecimal JavaDoc x) throws SQLException {
1163        }
1164        
1165        /**
1166         * Signature coverage for internal ResultSet implementation.
1167         */

1168        public void updateBinaryStream(int columnIndex, java.io.InputStream JavaDoc x, int length) throws SQLException {
1169        }
1170        
1171        /**
1172         * Signature coverage for internal ResultSet implementation.
1173         */

1174        public void updateBinaryStream(String JavaDoc columnName, java.io.InputStream JavaDoc x, int length) throws SQLException {
1175        }
1176        
1177        /**
1178         * Signature coverage for internal ResultSet implementation.
1179         */

1180        public void updateBlob(int columnIndex, java.sql.Blob JavaDoc x) throws SQLException {
1181        }
1182        
1183        /**
1184         * Signature coverage for internal ResultSet implementation.
1185         */

1186        public void updateBlob(String JavaDoc columnName, java.sql.Blob JavaDoc x) throws SQLException {
1187        }
1188        
1189        /**
1190         * Signature coverage for internal ResultSet implementation.
1191         */

1192        public void updateBoolean(int columnIndex, boolean x) throws SQLException {
1193        }
1194        
1195        /**
1196         * Signature coverage for internal ResultSet implementation.
1197         */

1198        public void updateBoolean(String JavaDoc columnName, boolean x) throws SQLException {
1199        }
1200        
1201        /**
1202         * Signature coverage for internal ResultSet implementation.
1203         */

1204        public void updateByte(int columnIndex, byte x) throws SQLException {
1205        }
1206        
1207        /**
1208         * Signature coverage for internal ResultSet implementation.
1209         */

1210        public void updateByte(String JavaDoc columnName, byte x) throws SQLException {
1211        }
1212        
1213        /**
1214         * Signature coverage for internal ResultSet implementation.
1215         */

1216        public void updateBytes(int columnIndex, byte[] x) throws SQLException {
1217        }
1218        
1219        /**
1220         * Signature coverage for internal ResultSet implementation.
1221         */

1222        public void updateBytes(String JavaDoc columnName, byte[] x) throws SQLException {
1223        }
1224        
1225        /**
1226         * Signature coverage for internal ResultSet implementation.
1227         */

1228        public void updateCharacterStream(int columnIndex, java.io.Reader JavaDoc x, int length) throws SQLException {
1229        }
1230        
1231        /**
1232         * Signature coverage for internal ResultSet implementation.
1233         */

1234        public void updateCharacterStream(String JavaDoc columnName, java.io.Reader JavaDoc reader, int length) throws SQLException {
1235        }
1236        
1237        /**
1238         * Signature coverage for internal ResultSet implementation.
1239         */

1240        public void updateClob(String JavaDoc columnName, java.sql.Clob JavaDoc x) throws SQLException {
1241        }
1242        
1243        /**
1244         * Signature coverage for internal ResultSet implementation.
1245         */

1246        public void updateClob(int columnIndex, java.sql.Clob JavaDoc x) throws SQLException {
1247        }
1248        
1249        /**
1250         * Signature coverage for internal ResultSet implementation.
1251         */

1252        public void updateDate(int columnIndex, java.sql.Date JavaDoc x) throws SQLException {
1253        }
1254        
1255        /**
1256         * Signature coverage for internal ResultSet implementation.
1257         */

1258        public void updateDate(String JavaDoc columnName, java.sql.Date JavaDoc x) throws SQLException {
1259        }
1260        
1261        /**
1262         * Signature coverage for internal ResultSet implementation.
1263         */

1264        public void updateDouble(int columnIndex, double x) throws SQLException {
1265        }
1266        
1267        /**
1268         * Signature coverage for internal ResultSet implementation.
1269         */

1270        public void updateDouble(String JavaDoc columnName, double x) throws SQLException {
1271        }
1272        
1273        /**
1274         * Signature coverage for internal ResultSet implementation.
1275         */

1276        public void updateFloat(String JavaDoc columnName, float x) throws SQLException {
1277        }
1278        
1279        /**
1280         * Signature coverage for internal ResultSet implementation.
1281         */

1282        public void updateFloat(int columnIndex, float x) throws SQLException {
1283        }
1284        
1285        /**
1286         * Signature coverage for internal ResultSet implementation.
1287         */

1288        public void updateInt(String JavaDoc columnName, int x) throws SQLException {
1289        }
1290        
1291        /**
1292         * Signature coverage for internal ResultSet implementation.
1293         */

1294        public void updateInt(int columnIndex, int x) throws SQLException {
1295        }
1296        
1297        /**
1298         * Signature coverage for internal ResultSet implementation.
1299         */

1300        public void updateLong(int columnIndex, long x) throws SQLException {
1301        }
1302        
1303        /**
1304         * Signature coverage for internal ResultSet implementation.
1305         */

1306        public void updateLong(String JavaDoc columnName, long x) throws SQLException {
1307        }
1308        
1309        /**
1310         * Signature coverage for internal ResultSet implementation.
1311         */

1312        public void updateNull(String JavaDoc columnName) throws SQLException {
1313        }
1314        
1315        /**
1316         * Signature coverage for internal ResultSet implementation.
1317         */

1318        public void updateNull(int columnIndex) throws SQLException {
1319        }
1320        
1321        /**
1322         * Signature coverage for internal ResultSet implementation.
1323         */

1324        public void updateObject(String JavaDoc columnName, Object JavaDoc x) throws SQLException {
1325        }
1326        
1327        /**
1328         * Signature coverage for internal ResultSet implementation.
1329         */

1330        public void updateObject(int columnIndex, Object JavaDoc x) throws SQLException {
1331        }
1332        
1333        /**
1334         * Signature coverage for internal ResultSet implementation.
1335         */

1336        public void updateObject(int columnIndex, Object JavaDoc x, int scale) throws SQLException {
1337        }
1338        
1339        /**
1340         * Signature coverage for internal ResultSet implementation.
1341         */

1342        public void updateObject(String JavaDoc columnName, Object JavaDoc x, int scale) throws SQLException {
1343        }
1344        
1345        /**
1346         * Signature coverage for internal ResultSet implementation.
1347         */

1348        public void updateRef(int columnIndex, java.sql.Ref JavaDoc x) throws SQLException {
1349        }
1350        
1351        /**
1352         * Signature coverage for internal ResultSet implementation.
1353         */

1354        public void updateRef(String JavaDoc columnName, java.sql.Ref JavaDoc x) throws SQLException {
1355        }
1356        
1357        /**
1358         * Signature coverage for internal ResultSet implementation.
1359         */

1360        public void updateRow() throws SQLException {
1361        }
1362        
1363        /**
1364         * Signature coverage for internal ResultSet implementation.
1365         */

1366        public void updateShort(int columnIndex, short x) throws SQLException {
1367        }
1368        
1369        /**
1370         * Signature coverage for internal ResultSet implementation.
1371         */

1372        public void updateShort(String JavaDoc columnName, short x) throws SQLException {
1373        }
1374        
1375        /**
1376         * Signature coverage for internal ResultSet implementation.
1377         */

1378        public void updateString(int columnIndex, String JavaDoc x) throws SQLException {
1379        }
1380        
1381        public void updateString(String JavaDoc columnName, String JavaDoc x) throws SQLException {
1382        }
1383        
1384        /**
1385         * Signature coverage for internal ResultSet implementation.
1386         */

1387        public void updateTime(String JavaDoc columnName, java.sql.Time JavaDoc x) throws SQLException {
1388        }
1389        
1390        /**
1391         * Signature coverage for internal ResultSet implementation.
1392         */

1393        public void updateTime(int columnIndex, java.sql.Time JavaDoc x) throws SQLException {
1394        }
1395        
1396        /**
1397         * Signature coverage for internal ResultSet implementation.
1398         */

1399        public void updateTimestamp(String JavaDoc columnName, java.sql.Timestamp JavaDoc x) throws SQLException {
1400        }
1401        
1402        /**
1403         * Signature coverage for internal ResultSet implementation.
1404         */

1405        public void updateTimestamp(int columnIndex, java.sql.Timestamp JavaDoc x) throws SQLException {
1406        }
1407        
1408        public boolean wasNull() throws SQLException {
1409            return false;
1410        }
1411        
1412    }
1413    
1414    /**
1415     * The identifier that assists in the serialization of this <code>SerialArray</code>
1416     * object.
1417     */

1418    static final long serialVersionUID = -8466174297270688520L;
1419}
1420
Popular Tags