|
1
30
31 package com.genimen.djeneric.jdbc;
32
33 import java.io.InputStream  ;
34 import java.io.Reader ;
35 import java.math.BigDecimal ;
36 import java.net.URL ;
37 import java.sql.Array ;
38 import java.sql.Blob ;
39 import java.sql.Clob ;
40 import java.sql.Date ;
41 import java.sql.Ref ;
42 import java.sql.ResultSet ;
43 import java.sql.ResultSetMetaData ;
44 import java.sql.SQLException ;
45 import java.sql.SQLWarning ;
46 import java.sql.Statement ;
47 import java.sql.Time ;
48 import java.sql.Timestamp ;
49 import java.util.ArrayList ;
50 import java.util.Calendar ;
51 import java.util.HashMap ;
52 import java.util.Iterator ;
53 import java.util.List ;
54 import java.util.Map ;
55
56 import com.genimen.djeneric.repository.DjDomain;
57 import com.genimen.djeneric.repository.DjProperty;
58 import com.genimen.djeneric.repository.DjPropertyType;
59 import com.genimen.djeneric.repository.exceptions.DjenericException;
60
61
67
68 public class DjResultSet implements ResultSet
69 {
70 private static final String DATATYPE_NOT_SUPPORTED = "This datatype is not supported by djeneric";
71 private static final String METHOD_NOT_IMPLEMENTED = "This method is not implemented by djeneric";
72 private static final String NOT_POSITIONED = "The resultset in not positioned on a row";
73 private static final String NO_COLUMN_POS = "There is no current column";
74
75
76 Map _columns = new HashMap ();
77 private List _allRows = new ArrayList ();
78 private int _position = -1;
79 private Object _lastColumn = null;
81 public String toString()
82 {
83 StringBuffer result = new StringBuffer (1024);
84 result.append("DjResultSet, containing ");
85 result.append(_allRows.size());
86 result.append(" rows\n");
87
88 result.append("Columns: ");
89 for (int colno = 1; colno <= _columns.size(); colno++)
90 {
91 result.append(getColumnDefinition(colno));
92 if (colno == _columns.size()) result.append("\n");
93 else result.append(", ");
94 }
95 int mx = _allRows.size() > 10 ? 10 : _allRows.size();
96 if (mx < _allRows.size()) result.append("First 10 rows:\n");
97 else result.append("Rows:\n");
98
99 for (int i = 0; i < mx; i++)
100 {
101 result.append(i);
102 result.append(": ");
103 result.append(_allRows.get(i));
104 result.append("\n");
105 }
106 return result.toString();
107 }
108
109 DjResultSet()
110 {
111 }
112
113 DjProperty[] defineAllColumnsFromResultSet(ResultSet p_original) throws SQLException , DjenericException
114 {
115 ResultSetMetaData meta = p_original.getMetaData();
116 DjProperty[] retval = new DjProperty[meta.getColumnCount()];
117 DjPropertyType STRING = new DjDomain("String", DjDomain.STRING_TYPE, 10, 0, "", "", false);
118 DjPropertyType BIGDEC = new DjDomain("BigDecimal", DjDomain.BIGDECIMAL_TYPE, 10, 0, "", "", false);
119 DjPropertyType DATETP = new DjDomain("Date", DjDomain.DATE_TYPE, 10, 0, "", "", false);
120 DjPropertyType INTTP = new DjDomain("Integer", DjDomain.INT_TYPE, 10, 0, "", "", false);
121
122 for (int i = 1; i <= meta.getColumnCount(); i++)
123 {
124 DjPropertyType tpe = null;
125 switch (meta.getColumnType(i))
126 {
127 case java.sql.Types.INTEGER :
128 case java.sql.Types.SMALLINT :
129 case java.sql.Types.TINYINT :
130 tpe = INTTP;
131 break;
132 case java.sql.Types.BIGINT :
133 case java.sql.Types.DECIMAL :
134 case java.sql.Types.DOUBLE :
135 case java.sql.Types.FLOAT :
136 case java.sql.Types.NUMERIC :
137 case java.sql.Types.REAL :
138 tpe = BIGDEC;
139 break;
140 case java.sql.Types.DATE :
141 tpe = DATETP;
142 break;
143 default :
144 tpe = STRING;
145 break;
146 }
147
148 DjProperty prop = new DjProperty(meta.getColumnLabel(i), "" , "" , meta.getColumnLabel(i), tpe, false, i, "", "");
151 retval[i - 1] = prop;
152 defineColumn(prop);
153 }
154 return retval;
155 }
156
157 static DjResultSet createFromResultSet(ResultSet p_original) throws SQLException , DjenericException
158 {
159 DjResultSet ret = new DjResultSet();
160 DjProperty[] props = ret.defineAllColumnsFromResultSet(p_original);
161
162 int numColumns = ret._columns.size();
163 while (p_original.next())
164 {
165 Object theRow = ret.newRow();
166 for (int col = 1; col <= numColumns; col++)
167 {
168 Object value = p_original.getObject(col);
169
170 ret.addColumn(theRow, props[col - 1], value);
171 }
172
173 }
174 p_original.close();
175 return ret;
176 }
177
178
179 DjProperty getColumnDefinition(int colno)
180 {
181 DjAssert.precondition(colno > 0); DjAssert.precondition(colno <= _columns.size()); DjProperty ret = null;
184 Iterator it = _columns.values().iterator();
185 while (it.hasNext())
186 {
187 ret = (DjProperty) it.next();
188 if (ret.getSeq() == colno) return ret;
189 }
190 return null;
191 }
192
193
194 void defineColumn(DjProperty p_col) throws SQLException
195 {
196 DjAssert.precondition(p_col != null);
197 if (_columns.containsKey(p_col.getName())) throw new SQLException ("Attempted to define duplicate column: "
198 + p_col.getName());
199 _columns.put(p_col.getName(), p_col);
200 }
201
202 void addColumn(Object p_row, DjProperty p_col, Object value)
203 {
204 DjAssert.precondition(p_row != null);
205 DjAssert.precondition(p_col != null);
206 DjAssert.precondition(_columns.containsKey(p_col.getName()));
207 int ix = p_col.getSeq() - 1;
208 List row = (List ) p_row;
209 Object original = row.set(ix, value);
210 DjAssert.check(null == original, "DjProperty was replaced");
211 }
212
213 Object newRow()
214 {
215 List rw = new ArrayList ();
216 for (int i = 0; i < _columns.size(); i++)
217 rw.add(null);
218 _allRows.add(rw);
219 return rw;
220 }
221
222 public boolean next() throws SQLException
223 {
224 _position++;
225 return _position < _allRows.size();
226 }
227
228 public void close()
229 {
230 _allRows.clear();
231 }
232
233 protected void finalize()
234 {
235 try
236 {
237 super.finalize();
238 close();
239 }
240 catch (Throwable e)
241 {
242 }
243 }
244
245
246 List getCurrentRow() throws SQLException
247 {
248 if (_position < 0 || _position >= _allRows.size()) throw new SQLException (NOT_POSITIONED);
249 return (List ) _allRows.get(_position);
250 }
251
252
253 List getRow(int rn) throws SQLException
254 {
255 return (List ) _allRows.get(rn);
256 }
257
258 private Object getColValue(int index) throws SQLException
259 {
260 _lastColumn = null;
261 List l = getCurrentRow();
262 if (index < 1 || index > l.size()) throw new SQLException ("No such column: " + index);
263 _lastColumn = l.get(index - 1);
264 return _lastColumn;
265 }
266
267 private Object getColValue(String colname) throws SQLException
268 {
269 DjProperty c = (DjProperty) _columns.get(colname);
270 if (c == null) throw new SQLException ("No such column: " + colname);
271 return getColValue(c.getSeq());
272 }
273
274 public boolean wasNull() throws SQLException
275 {
276 return _lastColumn == null;
277 }
278
279 public String getString(int columnIndex) throws SQLException
280 {
281 return ColumnConversion.toString(getColValue(columnIndex));
282 }
283
284 public boolean getBoolean(int columnIndex) throws SQLException
285 {
286 return ColumnConversion.toBoolean(getColValue(columnIndex)).booleanValue();
287 }
288
289 public byte getByte(int columnIndex) throws SQLException
290 {
291 throw new SQLException (DATATYPE_NOT_SUPPORTED);
292 }
293
294 public short getShort(int columnIndex) throws SQLException
295 {
296 return ColumnConversion.toBigDecimal(getColValue(columnIndex)).shortValue();
297 }
298
299 public int getInt(int columnIndex) throws SQLException
300 {
301 return ColumnConversion.toBigDecimal(getColValue(columnIndex)).intValue();
302 }
303
304 public long getLong(int columnIndex) throws SQLException
305 {
306 return ColumnConversion.toBigDecimal(getColValue(columnIndex)).longValue();
307 }
308
309 public float getFloat(int columnIndex) throws SQLException
310 {
311 return ColumnConversion.toBigDecimal(getColValue(columnIndex)).floatValue();
312 }
313
314 public double getDouble(int columnIndex) throws SQLException
315 {
316 return ColumnConversion.toBigDecimal(getColValue(columnIndex)).doubleValue();
317 }
318
319 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
320 {
321 return ColumnConversion.toBigDecimal(getColValue(columnIndex));
322 }
323
324 public byte[] getBytes(int columnIndex) throws SQLException
325 {
326 throw new SQLException (DATATYPE_NOT_SUPPORTED);
327 }
328
329 public Date getDate(int columnIndex) throws SQLException
330 {
331 return new java.sql.Date (ColumnConversion.toDate(getColValue(columnIndex)).getTime());
332 }
333
334 public Time getTime(int columnIndex) throws SQLException
335 {
336 return new Time (ColumnConversion.toDate(getColValue(columnIndex)).getTime());
337 }
338
339 public Timestamp getTimestamp(int columnIndex) throws SQLException
340 {
341 return new Timestamp (ColumnConversion.toDate(getColValue(columnIndex)).getTime());
342 }
343
344 public InputStream getAsciiStream(int columnIndex) throws SQLException
345 {
346 throw new SQLException (DATATYPE_NOT_SUPPORTED);
347 }
348
349 public InputStream getUnicodeStream(int columnIndex) throws SQLException
350 {
351 throw new SQLException (DATATYPE_NOT_SUPPORTED);
352 }
353
354 public InputStream getBinaryStream(int columnIndex) throws SQLException
355 {
356 throw new SQLException (DATATYPE_NOT_SUPPORTED);
357 }
358
359 public String getString(String columnName) throws SQLException
360 {
361 return getString(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
362 }
363
364 public boolean getBoolean(String columnName) throws SQLException
365 {
366 return getBoolean(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
367 }
368
369 public byte getByte(String columnName) throws SQLException
370 {
371 return getByte(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
372 }
373
374 public short getShort(String columnName) throws SQLException
375 {
376 return getShort(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
377 }
378
379 public int getInt(String columnName) throws SQLException
380 {
381 return getInt(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
382 }
383
384 public long getLong(String columnName) throws SQLException
385 {
386 return getLong(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
387 }
388
389 public float getFloat(String columnName) throws SQLException
390 {
391 return getFloat(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
392 }
393
394 public double getDouble(String columnName) throws SQLException
395 {
396 return getDouble(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
397 }
398
399 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
400 {
401 return getBigDecimal(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
402 }
403
404 public byte[] getBytes(String columnName) throws SQLException
405 {
406 return getBytes(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
407 }
408
409 public Date getDate(String columnName) throws SQLException
410 {
411 return getDate(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
412 }
413
414 public Time getTime(String columnName) throws SQLException
415 {
416 return getTime(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
417 }
418
419 public Timestamp getTimestamp(String columnName) throws SQLException
420 {
421 return getTimestamp(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
422 }
423
424 public InputStream getAsciiStream(String columnName) throws SQLException
425 {
426 return getAsciiStream(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
427 }
428
429 public InputStream getUnicodeStream(String columnName) throws SQLException
430 {
431 return getUnicodeStream(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
432 }
433
434 public InputStream getBinaryStream(String columnName) throws SQLException
435 {
436 return getBinaryStream(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
437 }
438
439 public SQLWarning getWarnings() throws SQLException
440 {
441 return null;
442 }
443
444 public void clearWarnings() throws SQLException
445 {
446 }
447
448 public String getCursorName() throws SQLException
449 {
450 throw new SQLException ("djrs.getCursorName: " + METHOD_NOT_IMPLEMENTED);
451 }
452
453 public ResultSetMetaData getMetaData() throws SQLException
454 {
455 return new DjResultSetMetaData(this);
456 }
457
458 public Object getObject(int columnIndex) throws SQLException
459 {
460 return getColValue(columnIndex);
461 }
462
463 public Object getObject(String columnName) throws SQLException
464 {
465 return getColValue(columnName);
466 }
467
468 public int findColumn(String columnName) throws SQLException
469 {
470 return ((DjProperty) _columns.get(columnName.toUpperCase())).getSeq();
471 }
472
473 public Reader getCharacterStream(int columnIndex) throws SQLException
474 {
475 throw new SQLException (DATATYPE_NOT_SUPPORTED);
476 }
477
478 public Reader getCharacterStream(String columnName) throws SQLException
479 {
480 throw new SQLException (DATATYPE_NOT_SUPPORTED);
481 }
482
483 public BigDecimal getBigDecimal(int columnIndex) throws SQLException
484 {
485 return ColumnConversion.toBigDecimal(getColValue(columnIndex));
486 }
487
488 public BigDecimal getBigDecimal(String columnName) throws SQLException
489 {
490 return getBigDecimal(((DjProperty) _columns.get(columnName.toUpperCase())).getSeq());
491 }
492
493 public boolean isBeforeFirst() throws SQLException
494 {
495 return _position == -1;
496 }
497
498 public boolean isAfterLast() throws SQLException
499 {
500 return _position >= _allRows.size();
501 }
502
503 public boolean isFirst() throws SQLException
504 {
505 return _position == 0;
506 }
507
508 public boolean isLast() throws SQLException
509 {
510 return _position == _allRows.size() - 1;
511 }
512
513 public void beforeFirst() throws SQLException
514 {
515 _position = -1;
516 }
517
518 public void afterLast() throws SQLException
519 {
520 _position = _allRows.size();
521 }
522
523 public boolean first() throws SQLException
524 {
525 _position = -1;
526 return next();
527 }
528
529 public boolean last() throws SQLException
530 {
531 _position = _allRows.size() - 2;
532 return next();
533 }
534
535 public int getRow() throws SQLException
536 {
537 return _allRows.size();
538 }
539
540 public boolean absolute(int row) throws SQLException
541 {
542 if (row < 0) throw new SQLException ("djrs.absolute<0: " + METHOD_NOT_IMPLEMENTED);
543 _position = row - 2;
544 return next();
545 }
546
547 public boolean relative(int rows) throws SQLException
548 {
549 _position += rows;
550
551 if (rows > 0)
552 {
553 _position--;
554 return next();
555 }
556 else
557 {
558 _position++;
559 return previous();
560 }
561 }
562
563 public boolean previous() throws SQLException
564 {
565 _position -= 2;
566 return next();
567 }
568
569 public void setFetchDirection(int direction) throws SQLException
570 {
571 throw new SQLException ("djrs.setFetchDirection: " + METHOD_NOT_IMPLEMENTED);
572 }
573
574 public int getFetchDirection() throws SQLException
575 {
576 throw new SQLException ("djrs.getFetchDirection: " + METHOD_NOT_IMPLEMENTED);
577 }
578
579 public void setFetchSize(int rows) throws SQLException
580 {
581 throw new SQLException ("djrs.setFetchSize: " + METHOD_NOT_IMPLEMENTED);
582 }
583
584 public int getFetchSize() throws SQLException
585 {
586 throw new SQLException ("djrs.getFetchSize: " + METHOD_NOT_IMPLEMENTED);
587 }
588
589 public int getType() throws SQLException
590 {
591 throw new SQLException ("djrs.getType: " + METHOD_NOT_IMPLEMENTED);
592 }
593
594 public int getConcurrency() throws SQLException
595 {
596 throw new SQLException ("djrs.getConcurrency: " + METHOD_NOT_IMPLEMENTED);
597 }
598
599 public boolean rowUpdated() throws SQLException
600 {
601 throw new SQLException ("djrs.rowUpdated: " + METHOD_NOT_IMPLEMENTED);
602 }
603
604 public boolean rowInserted() throws SQLException
605 {
606 throw new SQLException ("djrs.rowInserted: " + METHOD_NOT_IMPLEMENTED);
607 }
608
609 public boolean rowDeleted() throws SQLException
610 {
611 throw new SQLException ("djrs.rowDeleted: " + METHOD_NOT_IMPLEMENTED);
612 }
613
614 public void updateNull(int columnIndex) throws SQLException
615 {
616 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
617 }
618
619 public void updateBoolean(int columnIndex, boolean x) throws SQLException
620 {
621 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
622 }
623
624 public void updateByte(int columnIndex, byte x) throws SQLException
625 {
626 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
627 }
628
629 public void updateShort(int columnIndex, short x) throws SQLException
630 {
631 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
632 }
633
634 public void updateInt(int columnIndex, int x) throws SQLException
635 {
636 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
637 }
638
639 public void updateLong(int columnIndex, long x) throws SQLException
640 {
641 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
642 }
643
644 public void updateFloat(int columnIndex, float x) throws SQLException
645 {
646 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
647 }
648
649 public void updateDouble(int columnIndex, double x) throws SQLException
650 {
651 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
652 }
653
654 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException
655 {
656 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
657 }
658
659 public void updateString(int columnIndex, String x) throws SQLException
660 {
661 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
662 }
663
664 public void updateBytes(int columnIndex, byte[] x) throws SQLException
665 {
666 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
667 }
668
669 public void updateDate(int columnIndex, Date x) throws SQLException
670 {
671 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
672 }
673
674 public void updateTime(int columnIndex, Time x) throws SQLException
675 {
676 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
677 }
678
679 public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException
680 {
681 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
682 }
683
684 public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException
685 {
686 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
687 }
688
689 public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException
690 {
691 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
692 }
693
694 public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException
695 {
696 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
697 }
698
699 public void updateObject(int columnIndex, Object x, int scale) throws SQLException
700 {
701 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
702 }
703
704 public void updateObject(int columnIndex, Object x) throws SQLException
705 {
706 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
707 }
708
709 public void updateNull(String columnName) throws SQLException
710 {
711 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
712 }
713
714 public void updateBoolean(String columnName, boolean x) throws SQLException
715 {
716 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
717 }
718
719 public void updateByte(String columnName, byte x) throws SQLException
720 {
721 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
722 }
723
724 public void updateShort(String columnName, short x) throws SQLException
725 {
726 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
727 }
728
729 public void updateInt(String columnName, int x) throws SQLException
730 {
731 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
732 }
733
734 public void updateLong(String columnName, long x) throws SQLException
735 {
736 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
737 }
738
739 public void updateFloat(String columnName, float x) throws SQLException
740 {
741 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
742 }
743
744 public void updateDouble(String columnName, double x) throws SQLException
745 {
746 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
747 }
748
749 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException
750 {
751 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
752 }
753
754 public void updateString(String columnName, String x) throws SQLException
755 {
756 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
757 }
758
759 public void updateBytes(String columnName, byte[] x) throws SQLException
760 {
761 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
762 }
763
764 public void updateDate(String columnName, Date x) throws SQLException
765 {
766 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
767 }
768
769 public void updateTime(String columnName, Time x) throws SQLException
770 {
771 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
772 }
773
774 public void updateTimestamp(String columnName, Timestamp x) throws SQLException
775 {
776 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
777 }
778
779 public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException
780 {
781 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
782 }
783
784 public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException
785 {
786 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
787 }
788
789 public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException
790 {
791 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
792 }
793
794 public void updateObject(String columnName, Object x, int scale) throws SQLException
795 {
796 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
797 }
798
799 public void updateObject(String columnName, Object x) throws SQLException
800 {
801 throw new SQLException ("djrs.updatexxx: " + METHOD_NOT_IMPLEMENTED);
802 }
803
804 public void insertRow() throws SQLException
805 {
806 throw new SQLException ("djrs.insertRow: " + METHOD_NOT_IMPLEMENTED);
807 }
808
809 public void updateRow() throws SQLException
810 {
811 throw new SQLException ("djrs.updateRow: " + METHOD_NOT_IMPLEMENTED);
812 }
813
814 public void deleteRow() throws SQLException
815 {
816 throw new SQLException ("djrs.deleteRow: " + METHOD_NOT_IMPLEMENTED);
817 }
818
819 public void refreshRow() throws SQLException
820 {
821 throw new SQLException ("djrs.refreshRow: " + METHOD_NOT_IMPLEMENTED);
822 }
823
824 public void cancelRowUpdates() throws SQLException
825 {
826 throw new SQLException ("djrs.cancelRowUpdates: " + METHOD_NOT_IMPLEMENTED);
827 }
828
829 public void moveToInsertRow() throws SQLException
830 {
831 throw new SQLException ("djrs.moveToInsertRow: " + METHOD_NOT_IMPLEMENTED);
832 }
833
834 public void moveToCurrentRow() throws SQLException
835 {
836 throw new SQLException ("djrs.moveToCurrentRow: " + METHOD_NOT_IMPLEMENTED);
837 }
838
839 public Statement getStatement() throws SQLException
840 {
841
842 throw new SQLException ("djrs.getStatement: " + METHOD_NOT_IMPLEMENTED);
843 }
844
845 public Object getObject(int i, Map map) throws SQLException
846 {
847 throw new SQLException ("djrs.getObject: " + METHOD_NOT_IMPLEMENTED);
848 }
849
850 public Ref getRef(int i) throws SQLException
851 {
852 throw new SQLException ("djrs.getRef: " + METHOD_NOT_IMPLEMENTED);
853 }
854
855 public Blob getBlob(int i) throws SQLException
856 {
857 throw new SQLException ("djrs.getBlob: " + METHOD_NOT_IMPLEMENTED);
858 }
859
860 public Clob getClob(int i) throws SQLException
861 {
862 throw new SQLException ("djrs.getClob: " + METHOD_NOT_IMPLEMENTED);
863 }
864
865 public Array getArray(int i) throws SQLException
866 {
867 throw new SQLException ("djrs.getArray: " + METHOD_NOT_IMPLEMENTED);
868 }
869
870 public Object getObject(String colName, Map map) throws SQLException
871 {
872 throw new SQLException ("djrs.getObject: " + METHOD_NOT_IMPLEMENTED);
873 }
874
875 public Ref getRef(String colName) throws SQLException
876 {
877 throw new SQLException ("djrs.getRef: " + METHOD_NOT_IMPLEMENTED);
878 }
879
880 public Blob getBlob(String colName) throws SQLException
881 {
882 throw new SQLException ("djrs.getBlob: " + METHOD_NOT_IMPLEMENTED);
883 }
884
885 public Clob getClob(String colName) throws SQLException
886 {
887 throw new SQLException (METHOD_NOT_IMPLEMENTED);
888 }
889
890 public Array getArray(String colName) throws SQLException
891 {
892 throw new SQLException (METHOD_NOT_IMPLEMENTED);
893 }
894
895 public Date getDate(int columnIndex, Calendar cal) throws SQLException
896 {
897 throw new SQLException (METHOD_NOT_IMPLEMENTED);
898 }
899
900 public Date getDate(String columnName, Calendar cal) throws SQLException
901 {
902 throw new SQLException (METHOD_NOT_IMPLEMENTED);
903 }
904
905 public Time getTime(int columnIndex, Calendar cal) throws SQLException
906 {
907 throw new SQLException (METHOD_NOT_IMPLEMENTED);
908 }
909
910 public Time getTime(String columnName, Calendar cal) throws SQLException
911 {
912 throw new SQLException (METHOD_NOT_IMPLEMENTED);
913 }
914
915 public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException
916 {
917 throw new SQLException (METHOD_NOT_IMPLEMENTED);
918 }
919
920 public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException
921 {
922 throw new SQLException (METHOD_NOT_IMPLEMENTED);
923 }
924
925
930 public URL getURL(int arg0) throws SQLException
931 {
932 throw new SQLException (METHOD_NOT_IMPLEMENTED);
933 }
934
935
940 public URL getURL(String arg0) throws SQLException
941 {
942 throw new SQLException (METHOD_NOT_IMPLEMENTED);
943 }
944
945
950 public void updateArray(int arg0, Array arg1) throws SQLException
951 {
952 throw new SQLException (METHOD_NOT_IMPLEMENTED);
953 }
954
955
960 public void updateArray(String arg0, Array arg1) throws SQLException
961 {
962 throw new SQLException (METHOD_NOT_IMPLEMENTED);
963 }
964
965
970 public void updateBlob(int arg0, Blob arg1) throws SQLException
971 {
972 throw new SQLException (METHOD_NOT_IMPLEMENTED);
973 }
974
975
980 public void updateBlob(String arg0, Blob arg1) throws SQLException
981 {
982 throw new SQLException (METHOD_NOT_IMPLEMENTED);
983 }
984
985
990 public void updateClob(int arg0, Clob arg1) throws SQLException
991 {
992 throw new SQLException (METHOD_NOT_IMPLEMENTED);
993 }
994
995
1000 public void updateClob(String arg0, Clob arg1) throws SQLException
1001 {
1002 throw new SQLException (METHOD_NOT_IMPLEMENTED);
1003 }
1004
1005
1010 public void updateRef(int arg0, Ref arg1) throws SQLException
1011 {
1012 throw new SQLException (METHOD_NOT_IMPLEMENTED);
1013 }
1014
1015
1020 public void updateRef(String arg0, Ref arg1) throws SQLException
1021 {
1022 throw new SQLException (METHOD_NOT_IMPLEMENTED);
1023 }
1024
1025} |
Popular Tags |
Java API By Example, From Geeks To Geeks.