KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > caucho > tools > profiler > ResultSetWrapper


1 /*
2  * Copyright (c) 1998-2005 Caucho Technology -- all rights reserved
3  *
4  * This file is part of Resin(R) Open Source
5  *
6  * Each copy or derived work must preserve the copyright notice and this
7  * notice unmodified.
8  *
9  * Resin Open Source is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * Resin Open Source is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
17  * of NON-INFRINGEMENT. See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Resin Open Source; if not, write to the
22  * Free SoftwareFoundation, Inc.
23  * 59 Temple Place, Suite 330
24  * Boston, MA 02111-1307 USA
25  *
26  * @author Sam
27  */

28
29
30 package com.caucho.tools.profiler;
31
32 import java.io.InputStream JavaDoc;
33 import java.io.Reader JavaDoc;
34 import java.math.BigDecimal JavaDoc;
35 import java.net.URL JavaDoc;
36 import java.sql.*;
37 import java.util.Calendar JavaDoc;
38 import java.util.Map JavaDoc;
39
40 public final class ResultSetWrapper
41   implements ResultSet
42 {
43   private final ProfilerPoint _profilerPoint;
44   private final ResultSet _resultSet;
45
46   public ResultSetWrapper(ProfilerPoint profilerPoint, ResultSet resultSet)
47   {
48     _profilerPoint = profilerPoint;
49     _resultSet = resultSet;
50   }
51
52   public boolean next()
53     throws SQLException
54   {
55     Profiler profiler = _profilerPoint.start();
56
57     try {
58       return _resultSet.next();
59     }
60     finally {
61       profiler.finish();
62     }
63   }
64
65   public void close()
66     throws SQLException
67   {
68     Profiler profiler = _profilerPoint.start();
69
70     try {
71       _resultSet.close();
72     }
73     finally {
74       profiler.finish();
75     }
76   }
77
78   public boolean wasNull()
79     throws SQLException
80   {
81     Profiler profiler = _profilerPoint.start();
82
83     try {
84       return _resultSet.wasNull();
85     }
86     finally {
87       profiler.finish();
88     }
89   }
90
91   public String JavaDoc getString(int columnIndex)
92     throws SQLException
93   {
94     Profiler profiler = _profilerPoint.start();
95
96     try {
97       return _resultSet.getString(columnIndex);
98     }
99     finally {
100       profiler.finish();
101     }
102   }
103
104   public boolean getBoolean(int columnIndex)
105     throws SQLException
106   {
107     Profiler profiler = _profilerPoint.start();
108
109     try {
110       return _resultSet.getBoolean(columnIndex);
111     }
112     finally {
113       profiler.finish();
114     }
115   }
116
117   public byte getByte(int columnIndex)
118     throws SQLException
119   {
120     Profiler profiler = _profilerPoint.start();
121
122     try {
123       return _resultSet.getByte(columnIndex);
124     }
125     finally {
126       profiler.finish();
127     }
128   }
129
130   public short getShort(int columnIndex)
131     throws SQLException
132   {
133     Profiler profiler = _profilerPoint.start();
134
135     try {
136       return _resultSet.getShort(columnIndex);
137     }
138     finally {
139       profiler.finish();
140     }
141   }
142
143   public int getInt(int columnIndex)
144     throws SQLException
145   {
146     Profiler profiler = _profilerPoint.start();
147
148     try {
149       return _resultSet.getInt(columnIndex);
150     }
151     finally {
152       profiler.finish();
153     }
154   }
155
156   public long getLong(int columnIndex)
157     throws SQLException
158   {
159     Profiler profiler = _profilerPoint.start();
160
161     try {
162       return _resultSet.getLong(columnIndex);
163     }
164     finally {
165       profiler.finish();
166     }
167   }
168
169   public float getFloat(int columnIndex)
170     throws SQLException
171   {
172     Profiler profiler = _profilerPoint.start();
173
174     try {
175       return _resultSet.getFloat(columnIndex);
176     }
177     finally {
178       profiler.finish();
179     }
180   }
181
182   public double getDouble(int columnIndex)
183     throws SQLException
184   {
185     Profiler profiler = _profilerPoint.start();
186
187     try {
188       return _resultSet.getDouble(columnIndex);
189     }
190     finally {
191       profiler.finish();
192     }
193   }
194
195   public BigDecimal JavaDoc getBigDecimal(int columnIndex, int scale)
196     throws SQLException
197   {
198     Profiler profiler = _profilerPoint.start();
199
200     try {
201       return _resultSet.getBigDecimal(columnIndex, scale);
202     }
203     finally {
204       profiler.finish();
205     }
206   }
207
208   public byte[] getBytes(int columnIndex)
209     throws SQLException
210   {
211     Profiler profiler = _profilerPoint.start();
212
213     try {
214       return _resultSet.getBytes(columnIndex);
215     }
216     finally {
217       profiler.finish();
218     }
219   }
220
221   public Date getDate(int columnIndex)
222     throws SQLException
223   {
224     Profiler profiler = _profilerPoint.start();
225
226     try {
227       return _resultSet.getDate(columnIndex);
228     }
229     finally {
230       profiler.finish();
231     }
232   }
233
234   public Time getTime(int columnIndex)
235     throws SQLException
236   {
237     Profiler profiler = _profilerPoint.start();
238
239     try {
240       return _resultSet.getTime(columnIndex);
241     }
242     finally {
243       profiler.finish();
244     }
245   }
246
247   public Timestamp getTimestamp(int columnIndex)
248     throws SQLException
249   {
250     Profiler profiler = _profilerPoint.start();
251
252     try {
253       return _resultSet.getTimestamp(columnIndex);
254     }
255     finally {
256       profiler.finish();
257     }
258   }
259
260   public InputStream JavaDoc getAsciiStream(int columnIndex)
261     throws SQLException
262   {
263     Profiler profiler = _profilerPoint.start();
264
265     try {
266       return _resultSet.getAsciiStream(columnIndex);
267     }
268     finally {
269       profiler.finish();
270     }
271   }
272
273   /**
274    * @deprecated
275    */

276   public InputStream JavaDoc getUnicodeStream(int columnIndex)
277     throws SQLException
278   {
279     Profiler profiler = _profilerPoint.start();
280
281     try {
282       return _resultSet.getUnicodeStream(columnIndex);
283     }
284     finally {
285       profiler.finish();
286     }
287   }
288
289   public InputStream JavaDoc getBinaryStream(int columnIndex)
290     throws SQLException
291   {
292     Profiler profiler = _profilerPoint.start();
293
294     try {
295       return _resultSet.getBinaryStream(columnIndex);
296     }
297     finally {
298       profiler.finish();
299     }
300   }
301
302   public String JavaDoc getString(String JavaDoc columnName)
303     throws SQLException
304   {
305     Profiler profiler = _profilerPoint.start();
306
307     try {
308       return _resultSet.getString(columnName);
309     }
310     finally {
311       profiler.finish();
312     }
313   }
314
315   public boolean getBoolean(String JavaDoc columnName)
316     throws SQLException
317   {
318     Profiler profiler = _profilerPoint.start();
319
320     try {
321       return _resultSet.getBoolean(columnName);
322     }
323     finally {
324       profiler.finish();
325     }
326   }
327
328   public byte getByte(String JavaDoc columnName)
329     throws SQLException
330   {
331     Profiler profiler = _profilerPoint.start();
332
333     try {
334       return _resultSet.getByte(columnName);
335     }
336     finally {
337       profiler.finish();
338     }
339   }
340
341   public short getShort(String JavaDoc columnName)
342     throws SQLException
343   {
344     Profiler profiler = _profilerPoint.start();
345
346     try {
347       return _resultSet.getShort(columnName);
348     }
349     finally {
350       profiler.finish();
351     }
352   }
353
354   public int getInt(String JavaDoc columnName)
355     throws SQLException
356   {
357     Profiler profiler = _profilerPoint.start();
358
359     try {
360       return _resultSet.getInt(columnName);
361     }
362     finally {
363       profiler.finish();
364     }
365   }
366
367   public long getLong(String JavaDoc columnName)
368     throws SQLException
369   {
370     return _resultSet.getLong(columnName);
371   }
372
373   public float getFloat(String JavaDoc columnName)
374     throws SQLException
375   {
376     Profiler profiler = _profilerPoint.start();
377
378     try {
379       return _resultSet.getFloat(columnName);
380     }
381     finally {
382       profiler.finish();
383     }
384   }
385
386   public double getDouble(String JavaDoc columnName)
387     throws SQLException
388   {
389     return _resultSet.getDouble(columnName);
390   }
391
392   public BigDecimal JavaDoc getBigDecimal(String JavaDoc columnName, int scale)
393     throws SQLException
394   {
395     Profiler profiler = _profilerPoint.start();
396
397     try {
398       return _resultSet.getBigDecimal(columnName, scale);
399     }
400     finally {
401       profiler.finish();
402     }
403   }
404
405   public byte[] getBytes(String JavaDoc columnName)
406     throws SQLException
407   {
408     Profiler profiler = _profilerPoint.start();
409
410     try {
411       return _resultSet.getBytes(columnName);
412     }
413     finally {
414       profiler.finish();
415     }
416   }
417
418   public Date getDate(String JavaDoc columnName)
419     throws SQLException
420   {
421     Profiler profiler = _profilerPoint.start();
422
423     try {
424       return _resultSet.getDate(columnName);
425     }
426     finally {
427       profiler.finish();
428     }
429   }
430
431   public Time getTime(String JavaDoc columnName)
432     throws SQLException
433   {
434     Profiler profiler = _profilerPoint.start();
435
436     try {
437       return _resultSet.getTime(columnName);
438     }
439     finally {
440       profiler.finish();
441     }
442   }
443
444   public Timestamp getTimestamp(String JavaDoc columnName)
445     throws SQLException
446   {
447     Profiler profiler = _profilerPoint.start();
448
449     try {
450       return _resultSet.getTimestamp(columnName);
451     }
452     finally {
453       profiler.finish();
454     }
455   }
456
457   public InputStream JavaDoc getAsciiStream(String JavaDoc columnName)
458     throws SQLException
459   {
460     Profiler profiler = _profilerPoint.start();
461
462     try {
463       return _resultSet.getAsciiStream(columnName);
464     }
465     finally {
466       profiler.finish();
467     }
468   }
469
470   public InputStream JavaDoc getUnicodeStream(String JavaDoc columnName)
471     throws SQLException
472   {
473     Profiler profiler = _profilerPoint.start();
474
475     try {
476       return _resultSet.getUnicodeStream(columnName);
477     }
478     finally {
479       profiler.finish();
480     }
481   }
482
483   public InputStream JavaDoc getBinaryStream(String JavaDoc columnName)
484     throws SQLException
485   {
486     Profiler profiler = _profilerPoint.start();
487
488     try {
489       return _resultSet.getBinaryStream(columnName);
490     }
491     finally {
492       profiler.finish();
493     }
494   }
495
496   public SQLWarning getWarnings()
497     throws SQLException
498   {
499     Profiler profiler = _profilerPoint.start();
500
501     try {
502       return _resultSet.getWarnings();
503     }
504     finally {
505       profiler.finish();
506     }
507   }
508
509   public void clearWarnings()
510     throws SQLException
511   {
512     Profiler profiler = _profilerPoint.start();
513
514     try {
515       _resultSet.clearWarnings();
516     }
517     finally {
518       profiler.finish();
519     }
520   }
521
522   public String JavaDoc getCursorName()
523     throws SQLException
524   {
525     Profiler profiler = _profilerPoint.start();
526
527     try {
528       return _resultSet.getCursorName();
529     }
530     finally {
531       profiler.finish();
532     }
533   }
534
535   public ResultSetMetaData getMetaData()
536     throws SQLException
537   {
538     Profiler profiler = _profilerPoint.start();
539
540     try {
541       return _resultSet.getMetaData();
542     }
543     finally {
544       profiler.finish();
545     }
546   }
547
548   public Object JavaDoc getObject(int columnIndex)
549     throws SQLException
550   {
551     Profiler profiler = _profilerPoint.start();
552
553     try {
554       return _resultSet.getObject(columnIndex);
555     }
556     finally {
557       profiler.finish();
558     }
559   }
560
561   public Object JavaDoc getObject(String JavaDoc columnName)
562     throws SQLException
563   {
564     Profiler profiler = _profilerPoint.start();
565
566     try {
567       return _resultSet.getObject(columnName);
568     }
569     finally {
570       profiler.finish();
571     }
572   }
573
574   public int findColumn(String JavaDoc columnName)
575     throws SQLException
576   {
577     Profiler profiler = _profilerPoint.start();
578
579     try {
580       return _resultSet.findColumn(columnName);
581     }
582     finally {
583       profiler.finish();
584     }
585   }
586
587   public Reader JavaDoc getCharacterStream(int columnIndex)
588     throws SQLException
589   {
590     Profiler profiler = _profilerPoint.start();
591
592     try {
593       return _resultSet.getCharacterStream(columnIndex);
594     }
595     finally {
596       profiler.finish();
597     }
598   }
599
600   public Reader JavaDoc getCharacterStream(String JavaDoc columnName)
601     throws SQLException
602   {
603     Profiler profiler = _profilerPoint.start();
604
605     try {
606       return _resultSet.getCharacterStream(columnName);
607     }
608     finally {
609       profiler.finish();
610     }
611   }
612
613   public BigDecimal JavaDoc getBigDecimal(int columnIndex)
614     throws SQLException
615   {
616     Profiler profiler = _profilerPoint.start();
617
618     try {
619       return _resultSet.getBigDecimal(columnIndex);
620     }
621     finally {
622       profiler.finish();
623     }
624   }
625
626   public BigDecimal JavaDoc getBigDecimal(String JavaDoc columnName)
627     throws SQLException
628   {
629     Profiler profiler = _profilerPoint.start();
630
631     try {
632       return _resultSet.getBigDecimal(columnName);
633     }
634     finally {
635       profiler.finish();
636     }
637   }
638
639   public boolean isBeforeFirst()
640     throws SQLException
641   {
642     Profiler profiler = _profilerPoint.start();
643
644     try {
645       return _resultSet.isBeforeFirst();
646     }
647     finally {
648       profiler.finish();
649     }
650   }
651
652   public boolean isAfterLast()
653     throws SQLException
654   {
655     Profiler profiler = _profilerPoint.start();
656
657     try {
658       return _resultSet.isAfterLast();
659     }
660     finally {
661       profiler.finish();
662     }
663   }
664
665   public boolean isFirst()
666     throws SQLException
667   {
668     Profiler profiler = _profilerPoint.start();
669
670     try {
671       return _resultSet.isFirst();
672     }
673     finally {
674       profiler.finish();
675     }
676   }
677
678   public boolean isLast()
679     throws SQLException
680   {
681     Profiler profiler = _profilerPoint.start();
682
683     try {
684       return _resultSet.isLast();
685     }
686     finally {
687       profiler.finish();
688     }
689   }
690
691   public void beforeFirst()
692     throws SQLException
693   {
694     Profiler profiler = _profilerPoint.start();
695
696     try {
697       _resultSet.beforeFirst();
698     }
699     finally {
700       profiler.finish();
701     }
702   }
703
704   public void afterLast()
705     throws SQLException
706   {
707     Profiler profiler = _profilerPoint.start();
708
709     try {
710       _resultSet.afterLast();
711     }
712     finally {
713       profiler.finish();
714     }
715   }
716
717   public boolean first()
718     throws SQLException
719   {
720     Profiler profiler = _profilerPoint.start();
721
722     try {
723       return _resultSet.first();
724     }
725     finally {
726       profiler.finish();
727     }
728   }
729
730   public boolean last()
731     throws SQLException
732   {
733     Profiler profiler = _profilerPoint.start();
734
735     try {
736       return _resultSet.last();
737     }
738     finally {
739       profiler.finish();
740     }
741   }
742
743   public int getRow()
744     throws SQLException
745   {
746     Profiler profiler = _profilerPoint.start();
747
748     try {
749       return _resultSet.getRow();
750     }
751     finally {
752       profiler.finish();
753     }
754   }
755
756   public boolean absolute(int row)
757     throws SQLException
758   {
759     Profiler profiler = _profilerPoint.start();
760
761     try {
762       return _resultSet.absolute(row);
763     }
764     finally {
765       profiler.finish();
766     }
767   }
768
769   public boolean relative(int rows)
770     throws SQLException
771   {
772     Profiler profiler = _profilerPoint.start();
773
774     try {
775       return _resultSet.relative(rows);
776     }
777     finally {
778       profiler.finish();
779     }
780   }
781
782   public boolean previous()
783     throws SQLException
784   {
785     Profiler profiler = _profilerPoint.start();
786
787     try {
788       return _resultSet.previous();
789     }
790     finally {
791       profiler.finish();
792     }
793   }
794
795   public void setFetchDirection(int direction)
796     throws SQLException
797   {
798     Profiler profiler = _profilerPoint.start();
799
800     try {
801       _resultSet.setFetchDirection(direction);
802     }
803     finally {
804       profiler.finish();
805     }
806   }
807
808   public int getFetchDirection()
809     throws SQLException
810   {
811     Profiler profiler = _profilerPoint.start();
812
813     try {
814       return _resultSet.getFetchDirection();
815     }
816     finally {
817       profiler.finish();
818     }
819   }
820
821   public void setFetchSize(int rows)
822     throws SQLException
823   {
824     Profiler profiler = _profilerPoint.start();
825
826     try {
827       _resultSet.setFetchSize(rows);
828     }
829     finally {
830       profiler.finish();
831     }
832   }
833
834   public int getFetchSize()
835     throws SQLException
836   {
837     Profiler profiler = _profilerPoint.start();
838
839     try {
840       return _resultSet.getFetchSize();
841     }
842     finally {
843       profiler.finish();
844     }
845   }
846
847   public int getType()
848     throws SQLException
849   {
850     Profiler profiler = _profilerPoint.start();
851
852     try {
853       return _resultSet.getType();
854     }
855     finally {
856       profiler.finish();
857     }
858   }
859
860   public int getConcurrency()
861     throws SQLException
862   {
863     return _resultSet.getConcurrency();
864   }
865
866   public boolean rowUpdated()
867     throws SQLException
868   {
869     Profiler profiler = _profilerPoint.start();
870
871     try {
872       return _resultSet.rowUpdated();
873     }
874     finally {
875       profiler.finish();
876     }
877   }
878
879   public boolean rowInserted()
880     throws SQLException
881   {
882     Profiler profiler = _profilerPoint.start();
883
884     try {
885       return _resultSet.rowInserted();
886     }
887     finally {
888       profiler.finish();
889     }
890   }
891
892   public boolean rowDeleted()
893     throws SQLException
894   {
895     Profiler profiler = _profilerPoint.start();
896
897     try {
898       return _resultSet.rowDeleted();
899     }
900     finally {
901       profiler.finish();
902     }
903   }
904
905   public void updateNull(int columnIndex)
906     throws SQLException
907   {
908     Profiler profiler = _profilerPoint.start();
909
910     try {
911       _resultSet.updateNull(columnIndex);
912     }
913     finally {
914       profiler.finish();
915     }
916   }
917
918   public void updateBoolean(int columnIndex, boolean x)
919     throws SQLException
920   {
921     Profiler profiler = _profilerPoint.start();
922
923     try {
924       _resultSet.updateBoolean(columnIndex, x);
925     }
926     finally {
927       profiler.finish();
928     }
929   }
930
931   public void updateByte(int columnIndex, byte x)
932     throws SQLException
933   {
934     Profiler profiler = _profilerPoint.start();
935
936     try {
937       _resultSet.updateByte(columnIndex, x);
938     }
939     finally {
940       profiler.finish();
941     }
942   }
943
944   public void updateShort(int columnIndex, short x)
945     throws SQLException
946   {
947     Profiler profiler = _profilerPoint.start();
948
949     try {
950       _resultSet.updateShort(columnIndex, x);
951     }
952     finally {
953       profiler.finish();
954     }
955   }
956
957   public void updateInt(int columnIndex, int x)
958     throws SQLException
959   {
960     Profiler profiler = _profilerPoint.start();
961
962     try {
963       _resultSet.updateInt(columnIndex, x);
964     }
965     finally {
966       profiler.finish();
967     }
968   }
969
970   public void updateLong(int columnIndex, long x)
971     throws SQLException
972   {
973     Profiler profiler = _profilerPoint.start();
974
975     try {
976       _resultSet.updateLong(columnIndex, x);
977     }
978     finally {
979       profiler.finish();
980     }
981   }
982
983   public void updateFloat(int columnIndex, float x)
984     throws SQLException
985   {
986     Profiler profiler = _profilerPoint.start();
987
988     try {
989       _resultSet.updateFloat(columnIndex, x);
990     }
991     finally {
992       profiler.finish();
993     }
994   }
995
996   public void updateDouble(int columnIndex, double x)
997     throws SQLException
998   {
999     Profiler profiler = _profilerPoint.start();
1000
1001    try {
1002      _resultSet.updateDouble(columnIndex, x);
1003    }
1004    finally {
1005      profiler.finish();
1006    }
1007  }
1008
1009  public void updateBigDecimal(int columnIndex, BigDecimal JavaDoc x)
1010    throws SQLException
1011  {
1012    Profiler profiler = _profilerPoint.start();
1013
1014    try {
1015      _resultSet.updateBigDecimal(columnIndex, x);
1016    }
1017    finally {
1018      profiler.finish();
1019    }
1020  }
1021
1022  public void updateString(int columnIndex, String JavaDoc x)
1023    throws SQLException
1024  {
1025    Profiler profiler = _profilerPoint.start();
1026
1027    try {
1028      _resultSet.updateString(columnIndex, x);
1029    }
1030    finally {
1031      profiler.finish();
1032    }
1033  }
1034
1035  public void updateBytes(int columnIndex, byte[] x)
1036    throws SQLException
1037  {
1038    Profiler profiler = _profilerPoint.start();
1039
1040    try {
1041      _resultSet.updateBytes(columnIndex, x);
1042    }
1043    finally {
1044      profiler.finish();
1045    }
1046  }
1047
1048  public void updateDate(int columnIndex, Date x)
1049    throws SQLException
1050  {
1051    Profiler profiler = _profilerPoint.start();
1052
1053    try {
1054      _resultSet.updateDate(columnIndex, x);
1055    }
1056    finally {
1057      profiler.finish();
1058    }
1059  }
1060
1061  public void updateTime(int columnIndex, Time x)
1062    throws SQLException
1063  {
1064    Profiler profiler = _profilerPoint.start();
1065
1066    try {
1067      _resultSet.updateTime(columnIndex, x);
1068    }
1069    finally {
1070      profiler.finish();
1071    }
1072  }
1073
1074  public void updateTimestamp(int columnIndex, Timestamp x)
1075    throws SQLException
1076  {
1077    Profiler profiler = _profilerPoint.start();
1078
1079    try {
1080      _resultSet.updateTimestamp(columnIndex, x);
1081    }
1082    finally {
1083      profiler.finish();
1084    }
1085  }
1086
1087  public void updateAsciiStream(int columnIndex, InputStream JavaDoc x, int length)
1088    throws SQLException
1089  {
1090    Profiler profiler = _profilerPoint.start();
1091
1092    try {
1093      _resultSet.updateAsciiStream(columnIndex, x, length);
1094    }
1095    finally {
1096      profiler.finish();
1097    }
1098  }
1099
1100  public void updateBinaryStream(int columnIndex, InputStream JavaDoc x, int length)
1101    throws SQLException
1102  {
1103    Profiler profiler = _profilerPoint.start();
1104
1105    try {
1106      _resultSet.updateBinaryStream(columnIndex, x, length);
1107    }
1108    finally {
1109      profiler.finish();
1110    }
1111  }
1112
1113  public void updateCharacterStream(int columnIndex, Reader JavaDoc x, int length)
1114    throws SQLException
1115  {
1116    Profiler profiler = _profilerPoint.start();
1117
1118    try {
1119      _resultSet.updateCharacterStream(columnIndex, x, length);
1120    }
1121    finally {
1122      profiler.finish();
1123    }
1124  }
1125
1126  public void updateObject(int columnIndex, Object JavaDoc x, int scale)
1127    throws SQLException
1128  {
1129    Profiler profiler = _profilerPoint.start();
1130
1131    try {
1132      _resultSet.updateObject(columnIndex, x, scale);
1133    }
1134    finally {
1135      profiler.finish();
1136    }
1137  }
1138
1139  public void updateObject(int columnIndex, Object JavaDoc x)
1140    throws SQLException
1141  {
1142    Profiler profiler = _profilerPoint.start();
1143
1144    try {
1145      _resultSet.updateObject(columnIndex, x);
1146    }
1147    finally {
1148      profiler.finish();
1149    }
1150  }
1151
1152  public void updateNull(String JavaDoc columnName)
1153    throws SQLException
1154  {
1155    Profiler profiler = _profilerPoint.start();
1156
1157    try {
1158      _resultSet.updateNull(columnName);
1159    }
1160    finally {
1161      profiler.finish();
1162    }
1163  }
1164
1165  public void updateBoolean(String JavaDoc columnName, boolean x)
1166    throws SQLException
1167  {
1168    Profiler profiler = _profilerPoint.start();
1169
1170    try {
1171      _resultSet.updateBoolean(columnName, x);
1172    }
1173    finally {
1174      profiler.finish();
1175    }
1176  }
1177
1178  public void updateByte(String JavaDoc columnName, byte x)
1179    throws SQLException
1180  {
1181    Profiler profiler = _profilerPoint.start();
1182
1183    try {
1184      _resultSet.updateByte(columnName, x);
1185    }
1186    finally {
1187      profiler.finish();
1188    }
1189  }
1190
1191  public void updateShort(String JavaDoc columnName, short x)
1192    throws SQLException
1193  {
1194    Profiler profiler = _profilerPoint.start();
1195
1196    try {
1197      _resultSet.updateShort(columnName, x);
1198    }
1199    finally {
1200      profiler.finish();
1201    }
1202  }
1203
1204  public void updateInt(String JavaDoc columnName, int x)
1205    throws SQLException
1206  {
1207    Profiler profiler = _profilerPoint.start();
1208
1209    try {
1210      _resultSet.updateInt(columnName, x);
1211    }
1212    finally {
1213      profiler.finish();
1214    }
1215  }
1216
1217  public void updateLong(String JavaDoc columnName, long x)
1218    throws SQLException
1219  {
1220    Profiler profiler = _profilerPoint.start();
1221
1222    try {
1223      _resultSet.updateLong(columnName, x);
1224    }
1225    finally {
1226      profiler.finish();
1227    }
1228  }
1229
1230  public void updateFloat(String JavaDoc columnName, float x)
1231    throws SQLException
1232  {
1233    _resultSet.updateFloat(columnName, x);
1234  }
1235
1236  public void updateDouble(String JavaDoc columnName, double x)
1237    throws SQLException
1238  {
1239    Profiler profiler = _profilerPoint.start();
1240
1241    try {
1242      _resultSet.updateDouble(columnName, x);
1243    }
1244    finally {
1245      profiler.finish();
1246    }
1247  }
1248
1249  public void updateBigDecimal(String JavaDoc columnName, BigDecimal JavaDoc x)
1250    throws SQLException
1251  {
1252    Profiler profiler = _profilerPoint.start();
1253
1254    try {
1255      _resultSet.updateBigDecimal(columnName, x);
1256    }
1257    finally {
1258      profiler.finish();
1259    }
1260  }
1261
1262  public void updateString(String JavaDoc columnName, String JavaDoc x)
1263    throws SQLException
1264  {
1265    Profiler profiler = _profilerPoint.start();
1266
1267    try {
1268      _resultSet.updateString(columnName, x);
1269    }
1270    finally {
1271      profiler.finish();
1272    }
1273  }
1274
1275  public void updateBytes(String JavaDoc columnName, byte[] x)
1276    throws SQLException
1277  {
1278    Profiler profiler = _profilerPoint.start();
1279
1280    try {
1281      _resultSet.updateBytes(columnName, x);
1282    }
1283    finally {
1284      profiler.finish();
1285    }
1286  }
1287
1288  public void updateDate(String JavaDoc columnName, Date x)
1289    throws SQLException
1290  {
1291    Profiler profiler = _profilerPoint.start();
1292
1293    try {
1294      _resultSet.updateDate(columnName, x);
1295    }
1296    finally {
1297      profiler.finish();
1298    }
1299  }
1300
1301  public void updateTime(String JavaDoc columnName, Time x)
1302    throws SQLException
1303  {
1304    Profiler profiler = _profilerPoint.start();
1305
1306    try {
1307      _resultSet.updateTime(columnName, x);
1308    }
1309    finally {
1310      profiler.finish();
1311    }
1312  }
1313
1314  public void updateTimestamp(String JavaDoc columnName, Timestamp x)
1315    throws SQLException
1316  {
1317    Profiler profiler = _profilerPoint.start();
1318
1319    try {
1320      _resultSet.updateTimestamp(columnName, x);
1321    }
1322    finally {
1323      profiler.finish();
1324    }
1325  }
1326
1327  public void updateAsciiStream(String JavaDoc columnName, InputStream JavaDoc x, int length)
1328    throws SQLException
1329  {
1330    Profiler profiler = _profilerPoint.start();
1331
1332    try {
1333      _resultSet.updateAsciiStream(columnName, x, length);
1334    }
1335    finally {
1336      profiler.finish();
1337    }
1338  }
1339
1340  public void updateBinaryStream(String JavaDoc columnName, InputStream JavaDoc x, int length)
1341    throws SQLException
1342  {
1343    Profiler profiler = _profilerPoint.start();
1344
1345    try {
1346      _resultSet.updateBinaryStream(columnName, x, length);
1347    }
1348    finally {
1349      profiler.finish();
1350    }
1351  }
1352
1353  public void updateCharacterStream(String JavaDoc columnName,
1354                                    Reader JavaDoc reader,
1355                                    int length)
1356    throws SQLException
1357  {
1358    Profiler profiler = _profilerPoint.start();
1359
1360    try {
1361      _resultSet.updateCharacterStream(columnName, reader, length);
1362    }
1363    finally {
1364      profiler.finish();
1365    }
1366  }
1367
1368  public void updateObject(String JavaDoc columnName, Object JavaDoc x, int scale)
1369    throws SQLException
1370  {
1371    Profiler profiler = _profilerPoint.start();
1372
1373    try {
1374      _resultSet.updateObject(columnName, x, scale);
1375    }
1376    finally {
1377      profiler.finish();
1378    }
1379  }
1380
1381  public void updateObject(String JavaDoc columnName, Object JavaDoc x)
1382    throws SQLException
1383  {
1384    Profiler profiler = _profilerPoint.start();
1385
1386    try {
1387      _resultSet.updateObject(columnName, x);
1388    }
1389    finally {
1390      profiler.finish();
1391    }
1392  }
1393
1394  public void insertRow()
1395    throws SQLException
1396  {
1397    Profiler profiler = _profilerPoint.start();
1398
1399    try {
1400      _resultSet.insertRow();
1401    }
1402    finally {
1403      profiler.finish();
1404    }
1405  }
1406
1407  public void updateRow()
1408    throws SQLException
1409  {
1410    Profiler profiler = _profilerPoint.start();
1411
1412    try {
1413      _resultSet.updateRow();
1414    }
1415    finally {
1416      profiler.finish();
1417    }
1418  }
1419
1420  public void deleteRow()
1421    throws SQLException
1422  {
1423    Profiler profiler = _profilerPoint.start();
1424
1425    try {
1426      _resultSet.deleteRow();
1427    }
1428    finally {
1429      profiler.finish();
1430    }
1431  }
1432
1433  public void refreshRow()
1434    throws SQLException
1435  {
1436    Profiler profiler = _profilerPoint.start();
1437
1438    try {
1439      _resultSet.refreshRow();
1440    }
1441    finally {
1442      profiler.finish();
1443    }
1444  }
1445
1446  public void cancelRowUpdates()
1447    throws SQLException
1448  {
1449    Profiler profiler = _profilerPoint.start();
1450
1451    try {
1452      _resultSet.cancelRowUpdates();
1453    }
1454    finally {
1455      profiler.finish();
1456    }
1457  }
1458
1459  public void moveToInsertRow()
1460    throws SQLException
1461  {
1462    Profiler profiler = _profilerPoint.start();
1463
1464    try {
1465      _resultSet.moveToInsertRow();
1466    }
1467    finally {
1468      profiler.finish();
1469    }
1470  }
1471
1472  public void moveToCurrentRow()
1473    throws SQLException
1474  {
1475    Profiler profiler = _profilerPoint.start();
1476
1477    try {
1478      _resultSet.moveToCurrentRow();
1479    }
1480    finally {
1481      profiler.finish();
1482    }
1483  }
1484
1485  public Statement getStatement()
1486    throws SQLException
1487  {
1488    Profiler profiler = _profilerPoint.start();
1489
1490    try {
1491      return _resultSet.getStatement();
1492    }
1493    finally {
1494      profiler.finish();
1495    }
1496  }
1497
1498  public Object JavaDoc getObject(int i, Map JavaDoc<String JavaDoc, Class JavaDoc<?>> map)
1499    throws SQLException
1500  {
1501    Profiler profiler = _profilerPoint.start();
1502
1503    try {
1504      return _resultSet.getObject(i, map);
1505    }
1506    finally {
1507      profiler.finish();
1508    }
1509  }
1510
1511  public Ref getRef(int i)
1512    throws SQLException
1513  {
1514    Profiler profiler = _profilerPoint.start();
1515
1516    try {
1517      return _resultSet.getRef(i);
1518    }
1519    finally {
1520      profiler.finish();
1521    }
1522  }
1523
1524  public Blob getBlob(int i)
1525    throws SQLException
1526  {
1527    Profiler profiler = _profilerPoint.start();
1528
1529    try {
1530      return _resultSet.getBlob(i);
1531    }
1532    finally {
1533      profiler.finish();
1534    }
1535  }
1536
1537  public Clob getClob(int i)
1538    throws SQLException
1539  {
1540    Profiler profiler = _profilerPoint.start();
1541
1542    try {
1543      return _resultSet.getClob(i);
1544    }
1545    finally {
1546      profiler.finish();
1547    }
1548  }
1549
1550  public Array getArray(int i)
1551    throws SQLException
1552  {
1553    Profiler profiler = _profilerPoint.start();
1554
1555    try {
1556      return _resultSet.getArray(i);
1557    }
1558    finally {
1559      profiler.finish();
1560    }
1561  }
1562
1563  public Object JavaDoc getObject(String JavaDoc colName, Map JavaDoc<String JavaDoc, Class JavaDoc<?>> map)
1564    throws SQLException
1565  {
1566    Profiler profiler = _profilerPoint.start();
1567
1568    try {
1569      return _resultSet.getObject(colName, map);
1570    }
1571    finally {
1572      profiler.finish();
1573    }
1574  }
1575
1576  public Ref getRef(String JavaDoc colName)
1577    throws SQLException
1578  {
1579    Profiler profiler = _profilerPoint.start();
1580
1581    try {
1582      return _resultSet.getRef(colName);
1583    }
1584    finally {
1585      profiler.finish();
1586    }
1587  }
1588
1589  public Blob getBlob(String JavaDoc colName)
1590    throws SQLException
1591  {
1592    Profiler profiler = _profilerPoint.start();
1593
1594    try {
1595      return _resultSet.getBlob(colName);
1596    }
1597    finally {
1598      profiler.finish();
1599    }
1600  }
1601
1602  public Clob getClob(String JavaDoc colName)
1603    throws SQLException
1604  {
1605    Profiler profiler = _profilerPoint.start();
1606
1607    try {
1608      return _resultSet.getClob(colName);
1609    }
1610    finally {
1611      profiler.finish();
1612    }
1613  }
1614
1615  public Array getArray(String JavaDoc colName)
1616    throws SQLException
1617  {
1618    Profiler profiler = _profilerPoint.start();
1619
1620    try {
1621      return _resultSet.getArray(colName);
1622    }
1623    finally {
1624      profiler.finish();
1625    }
1626  }
1627
1628  public Date getDate(int columnIndex, Calendar JavaDoc cal)
1629    throws SQLException
1630  {
1631    Profiler profiler = _profilerPoint.start();
1632
1633    try {
1634      return _resultSet.getDate(columnIndex, cal);
1635    }
1636    finally {
1637      profiler.finish();
1638    }
1639  }
1640
1641  public Date getDate(String JavaDoc columnName, Calendar JavaDoc cal)
1642    throws SQLException
1643  {
1644    Profiler profiler = _profilerPoint.start();
1645
1646    try {
1647      return _resultSet.getDate(columnName, cal);
1648    }
1649    finally {
1650      profiler.finish();
1651    }
1652  }
1653
1654  public Time getTime(int columnIndex, Calendar JavaDoc cal)
1655    throws SQLException
1656  {
1657    Profiler profiler = _profilerPoint.start();
1658
1659    try {
1660      return _resultSet.getTime(columnIndex, cal);
1661    }
1662    finally {
1663      profiler.finish();
1664    }
1665  }
1666
1667  public Time getTime(String JavaDoc columnName, Calendar JavaDoc cal)
1668    throws SQLException
1669  {
1670    Profiler profiler = _profilerPoint.start();
1671
1672    try {
1673      return _resultSet.getTime(columnName, cal);
1674    }
1675    finally {
1676      profiler.finish();
1677    }
1678  }
1679
1680  public Timestamp getTimestamp(int columnIndex, Calendar JavaDoc cal)
1681    throws SQLException
1682  {
1683    Profiler profiler = _profilerPoint.start();
1684
1685    try {
1686      return _resultSet.getTimestamp(columnIndex, cal);
1687    }
1688    finally {
1689      profiler.finish();
1690    }
1691  }
1692
1693  public Timestamp getTimestamp(String JavaDoc columnName, Calendar JavaDoc cal)
1694    throws SQLException
1695  {
1696    Profiler profiler = _profilerPoint.start();
1697
1698    try {
1699      return _resultSet.getTimestamp(columnName, cal);
1700    }
1701    finally {
1702      profiler.finish();
1703    }
1704  }
1705
1706  public URL JavaDoc getURL(int columnIndex)
1707    throws SQLException
1708  {
1709    Profiler profiler = _profilerPoint.start();
1710
1711    try {
1712      return _resultSet.getURL(columnIndex);
1713    }
1714    finally {
1715      profiler.finish();
1716    }
1717  }
1718
1719  public URL JavaDoc getURL(String JavaDoc columnName)
1720    throws SQLException
1721  {
1722    Profiler profiler = _profilerPoint.start();
1723
1724    try {
1725      return _resultSet.getURL(columnName);
1726    }
1727    finally {
1728      profiler.finish();
1729    }
1730  }
1731
1732  public void updateRef(int columnIndex, Ref x)
1733    throws SQLException
1734  {
1735    Profiler profiler = _profilerPoint.start();
1736
1737    try {
1738      _resultSet.updateRef(columnIndex, x);
1739    }
1740    finally {
1741      profiler.finish();
1742    }
1743  }
1744
1745  public void updateRef(String JavaDoc columnName, Ref x)
1746    throws SQLException
1747  {
1748    Profiler profiler = _profilerPoint.start();
1749
1750    try {
1751      _resultSet.updateRef(columnName, x);
1752    }
1753    finally {
1754      profiler.finish();
1755    }
1756  }
1757
1758  public void updateBlob(int columnIndex, Blob x)
1759    throws SQLException
1760  {
1761    Profiler profiler = _profilerPoint.start();
1762
1763    try {
1764      _resultSet.updateBlob(columnIndex, x);
1765    }
1766    finally {
1767      profiler.finish();
1768    }
1769  }
1770
1771  public void updateBlob(String JavaDoc columnName, Blob x)
1772    throws SQLException
1773  {
1774    Profiler profiler = _profilerPoint.start();
1775
1776    try {
1777      _resultSet.updateBlob(columnName, x);
1778    }
1779    finally {
1780      profiler.finish();
1781    }
1782  }
1783
1784  public void updateClob(int columnIndex, Clob x)
1785    throws SQLException
1786  {
1787    Profiler profiler = _profilerPoint.start();
1788
1789    try {
1790      _resultSet.updateClob(columnIndex, x);
1791    }
1792    finally {
1793      profiler.finish();
1794    }
1795  }
1796
1797  public void updateClob(String JavaDoc columnName, Clob x)
1798    throws SQLException
1799  {
1800    Profiler profiler = _profilerPoint.start();
1801
1802    try {
1803      _resultSet.updateClob(columnName, x);
1804    }
1805    finally {
1806      profiler.finish();
1807    }
1808  }
1809
1810  public void updateArray(int columnIndex, Array x)
1811    throws SQLException
1812  {
1813    Profiler profiler = _profilerPoint.start();
1814
1815    try {
1816      _resultSet.updateArray(columnIndex, x);
1817    }
1818    finally {
1819      profiler.finish();
1820    }
1821  }
1822
1823  public void updateArray(String JavaDoc columnName, Array x)
1824    throws SQLException
1825  {
1826    Profiler profiler = _profilerPoint.start();
1827
1828    try {
1829      _resultSet.updateArray(columnName, x);
1830    }
1831    finally {
1832      profiler.finish();
1833    }
1834  }
1835
1836  public String JavaDoc toString()
1837  {
1838    return "ResultSetWrapper[" + _profilerPoint.getName() + "]";
1839  }
1840}
1841
Popular Tags