0001: /*
0002: * Copyright (c) 1998-2008 Caucho Technology -- all rights reserved
0003: *
0004: * This file is part of Resin(R) Open Source
0005: *
0006: * Each copy or derived work must preserve the copyright notice and this
0007: * notice unmodified.
0008: *
0009: * Resin Open Source is free software; you can redistribute it and/or modify
0010: * it under the terms of the GNU General Public License as published by
0011: * the Free Software Foundation; either version 2 of the License, or
0012: * (at your option) any later version.
0013: *
0014: * Resin Open Source is distributed in the hope that it will be useful,
0015: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0016: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
0017: * of NON-INFRINGEMENT. See the GNU General Public License for more
0018: * details.
0019: *
0020: * You should have received a copy of the GNU General Public License
0021: * along with Resin Open Source; if not, write to the
0022: * Free SoftwareFoundation, Inc.
0023: * 59 Temple Place, Suite 330
0024: * Boston, MA 02111-1307 USA
0025: *
0026: * @author Sam
0027: */
0028:
0029: package com.caucho.tools.profiler;
0030:
0031: import java.io.InputStream;
0032: import java.io.Reader;
0033: import java.math.BigDecimal;
0034: import java.net.URL;
0035: import java.sql.*;
0036: import java.util.Calendar;
0037: import java.util.Map;
0038:
0039: public final class ResultSetWrapper implements ResultSet {
0040: private final ProfilerPoint _profilerPoint;
0041: private final ResultSet _resultSet;
0042:
0043: public ResultSetWrapper(ProfilerPoint profilerPoint,
0044: ResultSet resultSet) {
0045: _profilerPoint = profilerPoint;
0046: _resultSet = resultSet;
0047: }
0048:
0049: public boolean next() throws SQLException {
0050: Profiler profiler = _profilerPoint.start();
0051:
0052: try {
0053: return _resultSet.next();
0054: } finally {
0055: profiler.finish();
0056: }
0057: }
0058:
0059: public void close() throws SQLException {
0060: Profiler profiler = _profilerPoint.start();
0061:
0062: try {
0063: _resultSet.close();
0064: } finally {
0065: profiler.finish();
0066: }
0067: }
0068:
0069: public boolean wasNull() throws SQLException {
0070: Profiler profiler = _profilerPoint.start();
0071:
0072: try {
0073: return _resultSet.wasNull();
0074: } finally {
0075: profiler.finish();
0076: }
0077: }
0078:
0079: public String getString(int columnIndex) throws SQLException {
0080: Profiler profiler = _profilerPoint.start();
0081:
0082: try {
0083: return _resultSet.getString(columnIndex);
0084: } finally {
0085: profiler.finish();
0086: }
0087: }
0088:
0089: public boolean getBoolean(int columnIndex) throws SQLException {
0090: Profiler profiler = _profilerPoint.start();
0091:
0092: try {
0093: return _resultSet.getBoolean(columnIndex);
0094: } finally {
0095: profiler.finish();
0096: }
0097: }
0098:
0099: public byte getByte(int columnIndex) throws SQLException {
0100: Profiler profiler = _profilerPoint.start();
0101:
0102: try {
0103: return _resultSet.getByte(columnIndex);
0104: } finally {
0105: profiler.finish();
0106: }
0107: }
0108:
0109: public short getShort(int columnIndex) throws SQLException {
0110: Profiler profiler = _profilerPoint.start();
0111:
0112: try {
0113: return _resultSet.getShort(columnIndex);
0114: } finally {
0115: profiler.finish();
0116: }
0117: }
0118:
0119: public int getInt(int columnIndex) throws SQLException {
0120: Profiler profiler = _profilerPoint.start();
0121:
0122: try {
0123: return _resultSet.getInt(columnIndex);
0124: } finally {
0125: profiler.finish();
0126: }
0127: }
0128:
0129: public long getLong(int columnIndex) throws SQLException {
0130: Profiler profiler = _profilerPoint.start();
0131:
0132: try {
0133: return _resultSet.getLong(columnIndex);
0134: } finally {
0135: profiler.finish();
0136: }
0137: }
0138:
0139: public float getFloat(int columnIndex) throws SQLException {
0140: Profiler profiler = _profilerPoint.start();
0141:
0142: try {
0143: return _resultSet.getFloat(columnIndex);
0144: } finally {
0145: profiler.finish();
0146: }
0147: }
0148:
0149: public double getDouble(int columnIndex) throws SQLException {
0150: Profiler profiler = _profilerPoint.start();
0151:
0152: try {
0153: return _resultSet.getDouble(columnIndex);
0154: } finally {
0155: profiler.finish();
0156: }
0157: }
0158:
0159: public BigDecimal getBigDecimal(int columnIndex, int scale)
0160: throws SQLException {
0161: Profiler profiler = _profilerPoint.start();
0162:
0163: try {
0164: return _resultSet.getBigDecimal(columnIndex, scale);
0165: } finally {
0166: profiler.finish();
0167: }
0168: }
0169:
0170: public byte[] getBytes(int columnIndex) throws SQLException {
0171: Profiler profiler = _profilerPoint.start();
0172:
0173: try {
0174: return _resultSet.getBytes(columnIndex);
0175: } finally {
0176: profiler.finish();
0177: }
0178: }
0179:
0180: public Date getDate(int columnIndex) throws SQLException {
0181: Profiler profiler = _profilerPoint.start();
0182:
0183: try {
0184: return _resultSet.getDate(columnIndex);
0185: } finally {
0186: profiler.finish();
0187: }
0188: }
0189:
0190: public Time getTime(int columnIndex) throws SQLException {
0191: Profiler profiler = _profilerPoint.start();
0192:
0193: try {
0194: return _resultSet.getTime(columnIndex);
0195: } finally {
0196: profiler.finish();
0197: }
0198: }
0199:
0200: public Timestamp getTimestamp(int columnIndex) throws SQLException {
0201: Profiler profiler = _profilerPoint.start();
0202:
0203: try {
0204: return _resultSet.getTimestamp(columnIndex);
0205: } finally {
0206: profiler.finish();
0207: }
0208: }
0209:
0210: public InputStream getAsciiStream(int columnIndex)
0211: throws SQLException {
0212: Profiler profiler = _profilerPoint.start();
0213:
0214: try {
0215: return _resultSet.getAsciiStream(columnIndex);
0216: } finally {
0217: profiler.finish();
0218: }
0219: }
0220:
0221: /**
0222: * @deprecated
0223: */
0224: public InputStream getUnicodeStream(int columnIndex)
0225: throws SQLException {
0226: Profiler profiler = _profilerPoint.start();
0227:
0228: try {
0229: return _resultSet.getUnicodeStream(columnIndex);
0230: } finally {
0231: profiler.finish();
0232: }
0233: }
0234:
0235: public InputStream getBinaryStream(int columnIndex)
0236: throws SQLException {
0237: Profiler profiler = _profilerPoint.start();
0238:
0239: try {
0240: return _resultSet.getBinaryStream(columnIndex);
0241: } finally {
0242: profiler.finish();
0243: }
0244: }
0245:
0246: public String getString(String columnName) throws SQLException {
0247: Profiler profiler = _profilerPoint.start();
0248:
0249: try {
0250: return _resultSet.getString(columnName);
0251: } finally {
0252: profiler.finish();
0253: }
0254: }
0255:
0256: public boolean getBoolean(String columnName) throws SQLException {
0257: Profiler profiler = _profilerPoint.start();
0258:
0259: try {
0260: return _resultSet.getBoolean(columnName);
0261: } finally {
0262: profiler.finish();
0263: }
0264: }
0265:
0266: public byte getByte(String columnName) throws SQLException {
0267: Profiler profiler = _profilerPoint.start();
0268:
0269: try {
0270: return _resultSet.getByte(columnName);
0271: } finally {
0272: profiler.finish();
0273: }
0274: }
0275:
0276: public short getShort(String columnName) throws SQLException {
0277: Profiler profiler = _profilerPoint.start();
0278:
0279: try {
0280: return _resultSet.getShort(columnName);
0281: } finally {
0282: profiler.finish();
0283: }
0284: }
0285:
0286: public int getInt(String columnName) throws SQLException {
0287: Profiler profiler = _profilerPoint.start();
0288:
0289: try {
0290: return _resultSet.getInt(columnName);
0291: } finally {
0292: profiler.finish();
0293: }
0294: }
0295:
0296: public long getLong(String columnName) throws SQLException {
0297: return _resultSet.getLong(columnName);
0298: }
0299:
0300: public float getFloat(String columnName) throws SQLException {
0301: Profiler profiler = _profilerPoint.start();
0302:
0303: try {
0304: return _resultSet.getFloat(columnName);
0305: } finally {
0306: profiler.finish();
0307: }
0308: }
0309:
0310: public double getDouble(String columnName) throws SQLException {
0311: return _resultSet.getDouble(columnName);
0312: }
0313:
0314: public BigDecimal getBigDecimal(String columnName, int scale)
0315: throws SQLException {
0316: Profiler profiler = _profilerPoint.start();
0317:
0318: try {
0319: return _resultSet.getBigDecimal(columnName, scale);
0320: } finally {
0321: profiler.finish();
0322: }
0323: }
0324:
0325: public byte[] getBytes(String columnName) throws SQLException {
0326: Profiler profiler = _profilerPoint.start();
0327:
0328: try {
0329: return _resultSet.getBytes(columnName);
0330: } finally {
0331: profiler.finish();
0332: }
0333: }
0334:
0335: public Date getDate(String columnName) throws SQLException {
0336: Profiler profiler = _profilerPoint.start();
0337:
0338: try {
0339: return _resultSet.getDate(columnName);
0340: } finally {
0341: profiler.finish();
0342: }
0343: }
0344:
0345: public Time getTime(String columnName) throws SQLException {
0346: Profiler profiler = _profilerPoint.start();
0347:
0348: try {
0349: return _resultSet.getTime(columnName);
0350: } finally {
0351: profiler.finish();
0352: }
0353: }
0354:
0355: public Timestamp getTimestamp(String columnName)
0356: throws SQLException {
0357: Profiler profiler = _profilerPoint.start();
0358:
0359: try {
0360: return _resultSet.getTimestamp(columnName);
0361: } finally {
0362: profiler.finish();
0363: }
0364: }
0365:
0366: public InputStream getAsciiStream(String columnName)
0367: throws SQLException {
0368: Profiler profiler = _profilerPoint.start();
0369:
0370: try {
0371: return _resultSet.getAsciiStream(columnName);
0372: } finally {
0373: profiler.finish();
0374: }
0375: }
0376:
0377: public InputStream getUnicodeStream(String columnName)
0378: throws SQLException {
0379: Profiler profiler = _profilerPoint.start();
0380:
0381: try {
0382: return _resultSet.getUnicodeStream(columnName);
0383: } finally {
0384: profiler.finish();
0385: }
0386: }
0387:
0388: public InputStream getBinaryStream(String columnName)
0389: throws SQLException {
0390: Profiler profiler = _profilerPoint.start();
0391:
0392: try {
0393: return _resultSet.getBinaryStream(columnName);
0394: } finally {
0395: profiler.finish();
0396: }
0397: }
0398:
0399: public SQLWarning getWarnings() throws SQLException {
0400: Profiler profiler = _profilerPoint.start();
0401:
0402: try {
0403: return _resultSet.getWarnings();
0404: } finally {
0405: profiler.finish();
0406: }
0407: }
0408:
0409: public void clearWarnings() throws SQLException {
0410: Profiler profiler = _profilerPoint.start();
0411:
0412: try {
0413: _resultSet.clearWarnings();
0414: } finally {
0415: profiler.finish();
0416: }
0417: }
0418:
0419: public String getCursorName() throws SQLException {
0420: Profiler profiler = _profilerPoint.start();
0421:
0422: try {
0423: return _resultSet.getCursorName();
0424: } finally {
0425: profiler.finish();
0426: }
0427: }
0428:
0429: public ResultSetMetaData getMetaData() throws SQLException {
0430: Profiler profiler = _profilerPoint.start();
0431:
0432: try {
0433: return _resultSet.getMetaData();
0434: } finally {
0435: profiler.finish();
0436: }
0437: }
0438:
0439: public Object getObject(int columnIndex) throws SQLException {
0440: Profiler profiler = _profilerPoint.start();
0441:
0442: try {
0443: return _resultSet.getObject(columnIndex);
0444: } finally {
0445: profiler.finish();
0446: }
0447: }
0448:
0449: public Object getObject(String columnName) throws SQLException {
0450: Profiler profiler = _profilerPoint.start();
0451:
0452: try {
0453: return _resultSet.getObject(columnName);
0454: } finally {
0455: profiler.finish();
0456: }
0457: }
0458:
0459: public int findColumn(String columnName) throws SQLException {
0460: Profiler profiler = _profilerPoint.start();
0461:
0462: try {
0463: return _resultSet.findColumn(columnName);
0464: } finally {
0465: profiler.finish();
0466: }
0467: }
0468:
0469: public Reader getCharacterStream(int columnIndex)
0470: throws SQLException {
0471: Profiler profiler = _profilerPoint.start();
0472:
0473: try {
0474: return _resultSet.getCharacterStream(columnIndex);
0475: } finally {
0476: profiler.finish();
0477: }
0478: }
0479:
0480: public Reader getCharacterStream(String columnName)
0481: throws SQLException {
0482: Profiler profiler = _profilerPoint.start();
0483:
0484: try {
0485: return _resultSet.getCharacterStream(columnName);
0486: } finally {
0487: profiler.finish();
0488: }
0489: }
0490:
0491: public BigDecimal getBigDecimal(int columnIndex)
0492: throws SQLException {
0493: Profiler profiler = _profilerPoint.start();
0494:
0495: try {
0496: return _resultSet.getBigDecimal(columnIndex);
0497: } finally {
0498: profiler.finish();
0499: }
0500: }
0501:
0502: public BigDecimal getBigDecimal(String columnName)
0503: throws SQLException {
0504: Profiler profiler = _profilerPoint.start();
0505:
0506: try {
0507: return _resultSet.getBigDecimal(columnName);
0508: } finally {
0509: profiler.finish();
0510: }
0511: }
0512:
0513: public boolean isBeforeFirst() throws SQLException {
0514: Profiler profiler = _profilerPoint.start();
0515:
0516: try {
0517: return _resultSet.isBeforeFirst();
0518: } finally {
0519: profiler.finish();
0520: }
0521: }
0522:
0523: public boolean isAfterLast() throws SQLException {
0524: Profiler profiler = _profilerPoint.start();
0525:
0526: try {
0527: return _resultSet.isAfterLast();
0528: } finally {
0529: profiler.finish();
0530: }
0531: }
0532:
0533: public boolean isFirst() throws SQLException {
0534: Profiler profiler = _profilerPoint.start();
0535:
0536: try {
0537: return _resultSet.isFirst();
0538: } finally {
0539: profiler.finish();
0540: }
0541: }
0542:
0543: public boolean isLast() throws SQLException {
0544: Profiler profiler = _profilerPoint.start();
0545:
0546: try {
0547: return _resultSet.isLast();
0548: } finally {
0549: profiler.finish();
0550: }
0551: }
0552:
0553: public void beforeFirst() throws SQLException {
0554: Profiler profiler = _profilerPoint.start();
0555:
0556: try {
0557: _resultSet.beforeFirst();
0558: } finally {
0559: profiler.finish();
0560: }
0561: }
0562:
0563: public void afterLast() throws SQLException {
0564: Profiler profiler = _profilerPoint.start();
0565:
0566: try {
0567: _resultSet.afterLast();
0568: } finally {
0569: profiler.finish();
0570: }
0571: }
0572:
0573: public boolean first() throws SQLException {
0574: Profiler profiler = _profilerPoint.start();
0575:
0576: try {
0577: return _resultSet.first();
0578: } finally {
0579: profiler.finish();
0580: }
0581: }
0582:
0583: public boolean last() throws SQLException {
0584: Profiler profiler = _profilerPoint.start();
0585:
0586: try {
0587: return _resultSet.last();
0588: } finally {
0589: profiler.finish();
0590: }
0591: }
0592:
0593: public int getRow() throws SQLException {
0594: Profiler profiler = _profilerPoint.start();
0595:
0596: try {
0597: return _resultSet.getRow();
0598: } finally {
0599: profiler.finish();
0600: }
0601: }
0602:
0603: public boolean absolute(int row) throws SQLException {
0604: Profiler profiler = _profilerPoint.start();
0605:
0606: try {
0607: return _resultSet.absolute(row);
0608: } finally {
0609: profiler.finish();
0610: }
0611: }
0612:
0613: public boolean relative(int rows) throws SQLException {
0614: Profiler profiler = _profilerPoint.start();
0615:
0616: try {
0617: return _resultSet.relative(rows);
0618: } finally {
0619: profiler.finish();
0620: }
0621: }
0622:
0623: public boolean previous() throws SQLException {
0624: Profiler profiler = _profilerPoint.start();
0625:
0626: try {
0627: return _resultSet.previous();
0628: } finally {
0629: profiler.finish();
0630: }
0631: }
0632:
0633: public void setFetchDirection(int direction) throws SQLException {
0634: Profiler profiler = _profilerPoint.start();
0635:
0636: try {
0637: _resultSet.setFetchDirection(direction);
0638: } finally {
0639: profiler.finish();
0640: }
0641: }
0642:
0643: public int getFetchDirection() throws SQLException {
0644: Profiler profiler = _profilerPoint.start();
0645:
0646: try {
0647: return _resultSet.getFetchDirection();
0648: } finally {
0649: profiler.finish();
0650: }
0651: }
0652:
0653: public void setFetchSize(int rows) throws SQLException {
0654: Profiler profiler = _profilerPoint.start();
0655:
0656: try {
0657: _resultSet.setFetchSize(rows);
0658: } finally {
0659: profiler.finish();
0660: }
0661: }
0662:
0663: public int getFetchSize() throws SQLException {
0664: Profiler profiler = _profilerPoint.start();
0665:
0666: try {
0667: return _resultSet.getFetchSize();
0668: } finally {
0669: profiler.finish();
0670: }
0671: }
0672:
0673: public int getType() throws SQLException {
0674: Profiler profiler = _profilerPoint.start();
0675:
0676: try {
0677: return _resultSet.getType();
0678: } finally {
0679: profiler.finish();
0680: }
0681: }
0682:
0683: public int getConcurrency() throws SQLException {
0684: return _resultSet.getConcurrency();
0685: }
0686:
0687: public boolean rowUpdated() throws SQLException {
0688: Profiler profiler = _profilerPoint.start();
0689:
0690: try {
0691: return _resultSet.rowUpdated();
0692: } finally {
0693: profiler.finish();
0694: }
0695: }
0696:
0697: public boolean rowInserted() throws SQLException {
0698: Profiler profiler = _profilerPoint.start();
0699:
0700: try {
0701: return _resultSet.rowInserted();
0702: } finally {
0703: profiler.finish();
0704: }
0705: }
0706:
0707: public boolean rowDeleted() throws SQLException {
0708: Profiler profiler = _profilerPoint.start();
0709:
0710: try {
0711: return _resultSet.rowDeleted();
0712: } finally {
0713: profiler.finish();
0714: }
0715: }
0716:
0717: public void updateNull(int columnIndex) throws SQLException {
0718: Profiler profiler = _profilerPoint.start();
0719:
0720: try {
0721: _resultSet.updateNull(columnIndex);
0722: } finally {
0723: profiler.finish();
0724: }
0725: }
0726:
0727: public void updateBoolean(int columnIndex, boolean x)
0728: throws SQLException {
0729: Profiler profiler = _profilerPoint.start();
0730:
0731: try {
0732: _resultSet.updateBoolean(columnIndex, x);
0733: } finally {
0734: profiler.finish();
0735: }
0736: }
0737:
0738: public void updateByte(int columnIndex, byte x) throws SQLException {
0739: Profiler profiler = _profilerPoint.start();
0740:
0741: try {
0742: _resultSet.updateByte(columnIndex, x);
0743: } finally {
0744: profiler.finish();
0745: }
0746: }
0747:
0748: public void updateShort(int columnIndex, short x)
0749: throws SQLException {
0750: Profiler profiler = _profilerPoint.start();
0751:
0752: try {
0753: _resultSet.updateShort(columnIndex, x);
0754: } finally {
0755: profiler.finish();
0756: }
0757: }
0758:
0759: public void updateInt(int columnIndex, int x) throws SQLException {
0760: Profiler profiler = _profilerPoint.start();
0761:
0762: try {
0763: _resultSet.updateInt(columnIndex, x);
0764: } finally {
0765: profiler.finish();
0766: }
0767: }
0768:
0769: public void updateLong(int columnIndex, long x) throws SQLException {
0770: Profiler profiler = _profilerPoint.start();
0771:
0772: try {
0773: _resultSet.updateLong(columnIndex, x);
0774: } finally {
0775: profiler.finish();
0776: }
0777: }
0778:
0779: public void updateFloat(int columnIndex, float x)
0780: throws SQLException {
0781: Profiler profiler = _profilerPoint.start();
0782:
0783: try {
0784: _resultSet.updateFloat(columnIndex, x);
0785: } finally {
0786: profiler.finish();
0787: }
0788: }
0789:
0790: public void updateDouble(int columnIndex, double x)
0791: throws SQLException {
0792: Profiler profiler = _profilerPoint.start();
0793:
0794: try {
0795: _resultSet.updateDouble(columnIndex, x);
0796: } finally {
0797: profiler.finish();
0798: }
0799: }
0800:
0801: public void updateBigDecimal(int columnIndex, BigDecimal x)
0802: throws SQLException {
0803: Profiler profiler = _profilerPoint.start();
0804:
0805: try {
0806: _resultSet.updateBigDecimal(columnIndex, x);
0807: } finally {
0808: profiler.finish();
0809: }
0810: }
0811:
0812: public void updateString(int columnIndex, String x)
0813: throws SQLException {
0814: Profiler profiler = _profilerPoint.start();
0815:
0816: try {
0817: _resultSet.updateString(columnIndex, x);
0818: } finally {
0819: profiler.finish();
0820: }
0821: }
0822:
0823: public void updateBytes(int columnIndex, byte[] x)
0824: throws SQLException {
0825: Profiler profiler = _profilerPoint.start();
0826:
0827: try {
0828: _resultSet.updateBytes(columnIndex, x);
0829: } finally {
0830: profiler.finish();
0831: }
0832: }
0833:
0834: public void updateDate(int columnIndex, Date x) throws SQLException {
0835: Profiler profiler = _profilerPoint.start();
0836:
0837: try {
0838: _resultSet.updateDate(columnIndex, x);
0839: } finally {
0840: profiler.finish();
0841: }
0842: }
0843:
0844: public void updateTime(int columnIndex, Time x) throws SQLException {
0845: Profiler profiler = _profilerPoint.start();
0846:
0847: try {
0848: _resultSet.updateTime(columnIndex, x);
0849: } finally {
0850: profiler.finish();
0851: }
0852: }
0853:
0854: public void updateTimestamp(int columnIndex, Timestamp x)
0855: throws SQLException {
0856: Profiler profiler = _profilerPoint.start();
0857:
0858: try {
0859: _resultSet.updateTimestamp(columnIndex, x);
0860: } finally {
0861: profiler.finish();
0862: }
0863: }
0864:
0865: public void updateAsciiStream(int columnIndex, InputStream x,
0866: int length) throws SQLException {
0867: Profiler profiler = _profilerPoint.start();
0868:
0869: try {
0870: _resultSet.updateAsciiStream(columnIndex, x, length);
0871: } finally {
0872: profiler.finish();
0873: }
0874: }
0875:
0876: public void updateBinaryStream(int columnIndex, InputStream x,
0877: int length) throws SQLException {
0878: Profiler profiler = _profilerPoint.start();
0879:
0880: try {
0881: _resultSet.updateBinaryStream(columnIndex, x, length);
0882: } finally {
0883: profiler.finish();
0884: }
0885: }
0886:
0887: public void updateCharacterStream(int columnIndex, Reader x,
0888: int length) throws SQLException {
0889: Profiler profiler = _profilerPoint.start();
0890:
0891: try {
0892: _resultSet.updateCharacterStream(columnIndex, x, length);
0893: } finally {
0894: profiler.finish();
0895: }
0896: }
0897:
0898: public void updateObject(int columnIndex, Object x, int scale)
0899: throws SQLException {
0900: Profiler profiler = _profilerPoint.start();
0901:
0902: try {
0903: _resultSet.updateObject(columnIndex, x, scale);
0904: } finally {
0905: profiler.finish();
0906: }
0907: }
0908:
0909: public void updateObject(int columnIndex, Object x)
0910: throws SQLException {
0911: Profiler profiler = _profilerPoint.start();
0912:
0913: try {
0914: _resultSet.updateObject(columnIndex, x);
0915: } finally {
0916: profiler.finish();
0917: }
0918: }
0919:
0920: public void updateNull(String columnName) throws SQLException {
0921: Profiler profiler = _profilerPoint.start();
0922:
0923: try {
0924: _resultSet.updateNull(columnName);
0925: } finally {
0926: profiler.finish();
0927: }
0928: }
0929:
0930: public void updateBoolean(String columnName, boolean x)
0931: throws SQLException {
0932: Profiler profiler = _profilerPoint.start();
0933:
0934: try {
0935: _resultSet.updateBoolean(columnName, x);
0936: } finally {
0937: profiler.finish();
0938: }
0939: }
0940:
0941: public void updateByte(String columnName, byte x)
0942: throws SQLException {
0943: Profiler profiler = _profilerPoint.start();
0944:
0945: try {
0946: _resultSet.updateByte(columnName, x);
0947: } finally {
0948: profiler.finish();
0949: }
0950: }
0951:
0952: public void updateShort(String columnName, short x)
0953: throws SQLException {
0954: Profiler profiler = _profilerPoint.start();
0955:
0956: try {
0957: _resultSet.updateShort(columnName, x);
0958: } finally {
0959: profiler.finish();
0960: }
0961: }
0962:
0963: public void updateInt(String columnName, int x) throws SQLException {
0964: Profiler profiler = _profilerPoint.start();
0965:
0966: try {
0967: _resultSet.updateInt(columnName, x);
0968: } finally {
0969: profiler.finish();
0970: }
0971: }
0972:
0973: public void updateLong(String columnName, long x)
0974: throws SQLException {
0975: Profiler profiler = _profilerPoint.start();
0976:
0977: try {
0978: _resultSet.updateLong(columnName, x);
0979: } finally {
0980: profiler.finish();
0981: }
0982: }
0983:
0984: public void updateFloat(String columnName, float x)
0985: throws SQLException {
0986: _resultSet.updateFloat(columnName, x);
0987: }
0988:
0989: public void updateDouble(String columnName, double x)
0990: throws SQLException {
0991: Profiler profiler = _profilerPoint.start();
0992:
0993: try {
0994: _resultSet.updateDouble(columnName, x);
0995: } finally {
0996: profiler.finish();
0997: }
0998: }
0999:
1000: public void updateBigDecimal(String columnName, BigDecimal x)
1001: throws SQLException {
1002: Profiler profiler = _profilerPoint.start();
1003:
1004: try {
1005: _resultSet.updateBigDecimal(columnName, x);
1006: } finally {
1007: profiler.finish();
1008: }
1009: }
1010:
1011: public void updateString(String columnName, String x)
1012: throws SQLException {
1013: Profiler profiler = _profilerPoint.start();
1014:
1015: try {
1016: _resultSet.updateString(columnName, x);
1017: } finally {
1018: profiler.finish();
1019: }
1020: }
1021:
1022: public void updateBytes(String columnName, byte[] x)
1023: throws SQLException {
1024: Profiler profiler = _profilerPoint.start();
1025:
1026: try {
1027: _resultSet.updateBytes(columnName, x);
1028: } finally {
1029: profiler.finish();
1030: }
1031: }
1032:
1033: public void updateDate(String columnName, Date x)
1034: throws SQLException {
1035: Profiler profiler = _profilerPoint.start();
1036:
1037: try {
1038: _resultSet.updateDate(columnName, x);
1039: } finally {
1040: profiler.finish();
1041: }
1042: }
1043:
1044: public void updateTime(String columnName, Time x)
1045: throws SQLException {
1046: Profiler profiler = _profilerPoint.start();
1047:
1048: try {
1049: _resultSet.updateTime(columnName, x);
1050: } finally {
1051: profiler.finish();
1052: }
1053: }
1054:
1055: public void updateTimestamp(String columnName, Timestamp x)
1056: throws SQLException {
1057: Profiler profiler = _profilerPoint.start();
1058:
1059: try {
1060: _resultSet.updateTimestamp(columnName, x);
1061: } finally {
1062: profiler.finish();
1063: }
1064: }
1065:
1066: public void updateAsciiStream(String columnName, InputStream x,
1067: int length) throws SQLException {
1068: Profiler profiler = _profilerPoint.start();
1069:
1070: try {
1071: _resultSet.updateAsciiStream(columnName, x, length);
1072: } finally {
1073: profiler.finish();
1074: }
1075: }
1076:
1077: public void updateBinaryStream(String columnName, InputStream x,
1078: int length) throws SQLException {
1079: Profiler profiler = _profilerPoint.start();
1080:
1081: try {
1082: _resultSet.updateBinaryStream(columnName, x, length);
1083: } finally {
1084: profiler.finish();
1085: }
1086: }
1087:
1088: public void updateCharacterStream(String columnName, Reader reader,
1089: int length) throws SQLException {
1090: Profiler profiler = _profilerPoint.start();
1091:
1092: try {
1093: _resultSet
1094: .updateCharacterStream(columnName, reader, length);
1095: } finally {
1096: profiler.finish();
1097: }
1098: }
1099:
1100: public void updateObject(String columnName, Object x, int scale)
1101: throws SQLException {
1102: Profiler profiler = _profilerPoint.start();
1103:
1104: try {
1105: _resultSet.updateObject(columnName, x, scale);
1106: } finally {
1107: profiler.finish();
1108: }
1109: }
1110:
1111: public void updateObject(String columnName, Object x)
1112: throws SQLException {
1113: Profiler profiler = _profilerPoint.start();
1114:
1115: try {
1116: _resultSet.updateObject(columnName, x);
1117: } finally {
1118: profiler.finish();
1119: }
1120: }
1121:
1122: public void insertRow() throws SQLException {
1123: Profiler profiler = _profilerPoint.start();
1124:
1125: try {
1126: _resultSet.insertRow();
1127: } finally {
1128: profiler.finish();
1129: }
1130: }
1131:
1132: public void updateRow() throws SQLException {
1133: Profiler profiler = _profilerPoint.start();
1134:
1135: try {
1136: _resultSet.updateRow();
1137: } finally {
1138: profiler.finish();
1139: }
1140: }
1141:
1142: public void deleteRow() throws SQLException {
1143: Profiler profiler = _profilerPoint.start();
1144:
1145: try {
1146: _resultSet.deleteRow();
1147: } finally {
1148: profiler.finish();
1149: }
1150: }
1151:
1152: public void refreshRow() throws SQLException {
1153: Profiler profiler = _profilerPoint.start();
1154:
1155: try {
1156: _resultSet.refreshRow();
1157: } finally {
1158: profiler.finish();
1159: }
1160: }
1161:
1162: public void cancelRowUpdates() throws SQLException {
1163: Profiler profiler = _profilerPoint.start();
1164:
1165: try {
1166: _resultSet.cancelRowUpdates();
1167: } finally {
1168: profiler.finish();
1169: }
1170: }
1171:
1172: public void moveToInsertRow() throws SQLException {
1173: Profiler profiler = _profilerPoint.start();
1174:
1175: try {
1176: _resultSet.moveToInsertRow();
1177: } finally {
1178: profiler.finish();
1179: }
1180: }
1181:
1182: public void moveToCurrentRow() throws SQLException {
1183: Profiler profiler = _profilerPoint.start();
1184:
1185: try {
1186: _resultSet.moveToCurrentRow();
1187: } finally {
1188: profiler.finish();
1189: }
1190: }
1191:
1192: public Statement getStatement() throws SQLException {
1193: Profiler profiler = _profilerPoint.start();
1194:
1195: try {
1196: return _resultSet.getStatement();
1197: } finally {
1198: profiler.finish();
1199: }
1200: }
1201:
1202: public Object getObject(int i, Map<String, Class<?>> map)
1203: throws SQLException {
1204: Profiler profiler = _profilerPoint.start();
1205:
1206: try {
1207: return _resultSet.getObject(i, map);
1208: } finally {
1209: profiler.finish();
1210: }
1211: }
1212:
1213: public Ref getRef(int i) throws SQLException {
1214: Profiler profiler = _profilerPoint.start();
1215:
1216: try {
1217: return _resultSet.getRef(i);
1218: } finally {
1219: profiler.finish();
1220: }
1221: }
1222:
1223: public Blob getBlob(int i) throws SQLException {
1224: Profiler profiler = _profilerPoint.start();
1225:
1226: try {
1227: return _resultSet.getBlob(i);
1228: } finally {
1229: profiler.finish();
1230: }
1231: }
1232:
1233: public Clob getClob(int i) throws SQLException {
1234: Profiler profiler = _profilerPoint.start();
1235:
1236: try {
1237: return _resultSet.getClob(i);
1238: } finally {
1239: profiler.finish();
1240: }
1241: }
1242:
1243: public Array getArray(int i) throws SQLException {
1244: Profiler profiler = _profilerPoint.start();
1245:
1246: try {
1247: return _resultSet.getArray(i);
1248: } finally {
1249: profiler.finish();
1250: }
1251: }
1252:
1253: public Object getObject(String colName, Map<String, Class<?>> map)
1254: throws SQLException {
1255: Profiler profiler = _profilerPoint.start();
1256:
1257: try {
1258: return _resultSet.getObject(colName, map);
1259: } finally {
1260: profiler.finish();
1261: }
1262: }
1263:
1264: public Ref getRef(String colName) throws SQLException {
1265: Profiler profiler = _profilerPoint.start();
1266:
1267: try {
1268: return _resultSet.getRef(colName);
1269: } finally {
1270: profiler.finish();
1271: }
1272: }
1273:
1274: public Blob getBlob(String colName) throws SQLException {
1275: Profiler profiler = _profilerPoint.start();
1276:
1277: try {
1278: return _resultSet.getBlob(colName);
1279: } finally {
1280: profiler.finish();
1281: }
1282: }
1283:
1284: public Clob getClob(String colName) throws SQLException {
1285: Profiler profiler = _profilerPoint.start();
1286:
1287: try {
1288: return _resultSet.getClob(colName);
1289: } finally {
1290: profiler.finish();
1291: }
1292: }
1293:
1294: public Array getArray(String colName) throws SQLException {
1295: Profiler profiler = _profilerPoint.start();
1296:
1297: try {
1298: return _resultSet.getArray(colName);
1299: } finally {
1300: profiler.finish();
1301: }
1302: }
1303:
1304: public Date getDate(int columnIndex, Calendar cal)
1305: throws SQLException {
1306: Profiler profiler = _profilerPoint.start();
1307:
1308: try {
1309: return _resultSet.getDate(columnIndex, cal);
1310: } finally {
1311: profiler.finish();
1312: }
1313: }
1314:
1315: public Date getDate(String columnName, Calendar cal)
1316: throws SQLException {
1317: Profiler profiler = _profilerPoint.start();
1318:
1319: try {
1320: return _resultSet.getDate(columnName, cal);
1321: } finally {
1322: profiler.finish();
1323: }
1324: }
1325:
1326: public Time getTime(int columnIndex, Calendar cal)
1327: throws SQLException {
1328: Profiler profiler = _profilerPoint.start();
1329:
1330: try {
1331: return _resultSet.getTime(columnIndex, cal);
1332: } finally {
1333: profiler.finish();
1334: }
1335: }
1336:
1337: public Time getTime(String columnName, Calendar cal)
1338: throws SQLException {
1339: Profiler profiler = _profilerPoint.start();
1340:
1341: try {
1342: return _resultSet.getTime(columnName, cal);
1343: } finally {
1344: profiler.finish();
1345: }
1346: }
1347:
1348: public Timestamp getTimestamp(int columnIndex, Calendar cal)
1349: throws SQLException {
1350: Profiler profiler = _profilerPoint.start();
1351:
1352: try {
1353: return _resultSet.getTimestamp(columnIndex, cal);
1354: } finally {
1355: profiler.finish();
1356: }
1357: }
1358:
1359: public Timestamp getTimestamp(String columnName, Calendar cal)
1360: throws SQLException {
1361: Profiler profiler = _profilerPoint.start();
1362:
1363: try {
1364: return _resultSet.getTimestamp(columnName, cal);
1365: } finally {
1366: profiler.finish();
1367: }
1368: }
1369:
1370: public URL getURL(int columnIndex) throws SQLException {
1371: Profiler profiler = _profilerPoint.start();
1372:
1373: try {
1374: return _resultSet.getURL(columnIndex);
1375: } finally {
1376: profiler.finish();
1377: }
1378: }
1379:
1380: public URL getURL(String columnName) throws SQLException {
1381: Profiler profiler = _profilerPoint.start();
1382:
1383: try {
1384: return _resultSet.getURL(columnName);
1385: } finally {
1386: profiler.finish();
1387: }
1388: }
1389:
1390: public void updateRef(int columnIndex, Ref x) throws SQLException {
1391: Profiler profiler = _profilerPoint.start();
1392:
1393: try {
1394: _resultSet.updateRef(columnIndex, x);
1395: } finally {
1396: profiler.finish();
1397: }
1398: }
1399:
1400: public void updateRef(String columnName, Ref x) throws SQLException {
1401: Profiler profiler = _profilerPoint.start();
1402:
1403: try {
1404: _resultSet.updateRef(columnName, x);
1405: } finally {
1406: profiler.finish();
1407: }
1408: }
1409:
1410: public void updateBlob(int columnIndex, Blob x) throws SQLException {
1411: Profiler profiler = _profilerPoint.start();
1412:
1413: try {
1414: _resultSet.updateBlob(columnIndex, x);
1415: } finally {
1416: profiler.finish();
1417: }
1418: }
1419:
1420: public void updateBlob(String columnName, Blob x)
1421: throws SQLException {
1422: Profiler profiler = _profilerPoint.start();
1423:
1424: try {
1425: _resultSet.updateBlob(columnName, x);
1426: } finally {
1427: profiler.finish();
1428: }
1429: }
1430:
1431: public void updateClob(int columnIndex, Clob x) throws SQLException {
1432: Profiler profiler = _profilerPoint.start();
1433:
1434: try {
1435: _resultSet.updateClob(columnIndex, x);
1436: } finally {
1437: profiler.finish();
1438: }
1439: }
1440:
1441: public void updateClob(String columnName, Clob x)
1442: throws SQLException {
1443: Profiler profiler = _profilerPoint.start();
1444:
1445: try {
1446: _resultSet.updateClob(columnName, x);
1447: } finally {
1448: profiler.finish();
1449: }
1450: }
1451:
1452: public void updateArray(int columnIndex, Array x)
1453: throws SQLException {
1454: Profiler profiler = _profilerPoint.start();
1455:
1456: try {
1457: _resultSet.updateArray(columnIndex, x);
1458: } finally {
1459: profiler.finish();
1460: }
1461: }
1462:
1463: public void updateArray(String columnName, Array x)
1464: throws SQLException {
1465: Profiler profiler = _profilerPoint.start();
1466:
1467: try {
1468: _resultSet.updateArray(columnName, x);
1469: } finally {
1470: profiler.finish();
1471: }
1472: }
1473:
1474: public String toString() {
1475: return "ResultSetWrapper[" + _profilerPoint.getName() + "]";
1476: }
1477:
1478: public RowId getRowId(int columnIndex) throws SQLException {
1479: throw new UnsupportedOperationException("Not supported yet.");
1480: }
1481:
1482: public RowId getRowId(String columnLabel) throws SQLException {
1483: throw new UnsupportedOperationException("Not supported yet.");
1484: }
1485:
1486: public void updateRowId(int columnIndex, RowId x)
1487: throws SQLException {
1488: throw new UnsupportedOperationException("Not supported yet.");
1489: }
1490:
1491: public void updateRowId(String columnLabel, RowId x)
1492: throws SQLException {
1493: throw new UnsupportedOperationException("Not supported yet.");
1494: }
1495:
1496: public int getHoldability() throws SQLException {
1497: throw new UnsupportedOperationException("Not supported yet.");
1498: }
1499:
1500: public boolean isClosed() throws SQLException {
1501: throw new UnsupportedOperationException("Not supported yet.");
1502: }
1503:
1504: public void updateNString(int columnIndex, String nString)
1505: throws SQLException {
1506: throw new UnsupportedOperationException("Not supported yet.");
1507: }
1508:
1509: public void updateNString(String columnLabel, String nString)
1510: throws SQLException {
1511: throw new UnsupportedOperationException("Not supported yet.");
1512: }
1513:
1514: public void updateNClob(int columnIndex, NClob nClob)
1515: throws SQLException {
1516: throw new UnsupportedOperationException("Not supported yet.");
1517: }
1518:
1519: public void updateNClob(String columnLabel, NClob nClob)
1520: throws SQLException {
1521: throw new UnsupportedOperationException("Not supported yet.");
1522: }
1523:
1524: public NClob getNClob(int columnIndex) throws SQLException {
1525: throw new UnsupportedOperationException("Not supported yet.");
1526: }
1527:
1528: public NClob getNClob(String columnLabel) throws SQLException {
1529: throw new UnsupportedOperationException("Not supported yet.");
1530: }
1531:
1532: public SQLXML getSQLXML(int columnIndex) throws SQLException {
1533: throw new UnsupportedOperationException("Not supported yet.");
1534: }
1535:
1536: public SQLXML getSQLXML(String columnLabel) throws SQLException {
1537: throw new UnsupportedOperationException("Not supported yet.");
1538: }
1539:
1540: public void updateSQLXML(int columnIndex, SQLXML xmlObject)
1541: throws SQLException {
1542: throw new UnsupportedOperationException("Not supported yet.");
1543: }
1544:
1545: public void updateSQLXML(String columnLabel, SQLXML xmlObject)
1546: throws SQLException {
1547: throw new UnsupportedOperationException("Not supported yet.");
1548: }
1549:
1550: public String getNString(int columnIndex) throws SQLException {
1551: throw new UnsupportedOperationException("Not supported yet.");
1552: }
1553:
1554: public String getNString(String columnLabel) throws SQLException {
1555: throw new UnsupportedOperationException("Not supported yet.");
1556: }
1557:
1558: public Reader getNCharacterStream(int columnIndex)
1559: throws SQLException {
1560: throw new UnsupportedOperationException("Not supported yet.");
1561: }
1562:
1563: public Reader getNCharacterStream(String columnLabel)
1564: throws SQLException {
1565: throw new UnsupportedOperationException("Not supported yet.");
1566: }
1567:
1568: public void updateNCharacterStream(int columnIndex, Reader x,
1569: long length) throws SQLException {
1570: throw new UnsupportedOperationException("Not supported yet.");
1571: }
1572:
1573: public void updateNCharacterStream(String columnLabel,
1574: Reader reader, long length) throws SQLException {
1575: throw new UnsupportedOperationException("Not supported yet.");
1576: }
1577:
1578: public void updateAsciiStream(int columnIndex, InputStream x,
1579: long length) throws SQLException {
1580: throw new UnsupportedOperationException("Not supported yet.");
1581: }
1582:
1583: public void updateBinaryStream(int columnIndex, InputStream x,
1584: long length) throws SQLException {
1585: throw new UnsupportedOperationException("Not supported yet.");
1586: }
1587:
1588: public void updateCharacterStream(int columnIndex, Reader x,
1589: long length) throws SQLException {
1590: throw new UnsupportedOperationException("Not supported yet.");
1591: }
1592:
1593: public void updateAsciiStream(String columnLabel, InputStream x,
1594: long length) throws SQLException {
1595: throw new UnsupportedOperationException("Not supported yet.");
1596: }
1597:
1598: public void updateBinaryStream(String columnLabel, InputStream x,
1599: long length) throws SQLException {
1600: throw new UnsupportedOperationException("Not supported yet.");
1601: }
1602:
1603: public void updateCharacterStream(String columnLabel,
1604: Reader reader, long length) throws SQLException {
1605: throw new UnsupportedOperationException("Not supported yet.");
1606: }
1607:
1608: public void updateBlob(int columnIndex, InputStream inputStream,
1609: long length) throws SQLException {
1610: throw new UnsupportedOperationException("Not supported yet.");
1611: }
1612:
1613: public void updateBlob(String columnLabel, InputStream inputStream,
1614: long length) throws SQLException {
1615: throw new UnsupportedOperationException("Not supported yet.");
1616: }
1617:
1618: public void updateClob(int columnIndex, Reader reader, long length)
1619: throws SQLException {
1620: throw new UnsupportedOperationException("Not supported yet.");
1621: }
1622:
1623: public void updateClob(String columnLabel, Reader reader,
1624: long length) throws SQLException {
1625: throw new UnsupportedOperationException("Not supported yet.");
1626: }
1627:
1628: public void updateNClob(int columnIndex, Reader reader, long length)
1629: throws SQLException {
1630: throw new UnsupportedOperationException("Not supported yet.");
1631: }
1632:
1633: public void updateNClob(String columnLabel, Reader reader,
1634: long length) throws SQLException {
1635: throw new UnsupportedOperationException("Not supported yet.");
1636: }
1637:
1638: public void updateNCharacterStream(int columnIndex, Reader x)
1639: throws SQLException {
1640: throw new UnsupportedOperationException("Not supported yet.");
1641: }
1642:
1643: public void updateNCharacterStream(String columnLabel, Reader reader)
1644: throws SQLException {
1645: throw new UnsupportedOperationException("Not supported yet.");
1646: }
1647:
1648: public void updateAsciiStream(int columnIndex, InputStream x)
1649: throws SQLException {
1650: throw new UnsupportedOperationException("Not supported yet.");
1651: }
1652:
1653: public void updateBinaryStream(int columnIndex, InputStream x)
1654: throws SQLException {
1655: throw new UnsupportedOperationException("Not supported yet.");
1656: }
1657:
1658: public void updateCharacterStream(int columnIndex, Reader x)
1659: throws SQLException {
1660: throw new UnsupportedOperationException("Not supported yet.");
1661: }
1662:
1663: public void updateAsciiStream(String columnLabel, InputStream x)
1664: throws SQLException {
1665: throw new UnsupportedOperationException("Not supported yet.");
1666: }
1667:
1668: public void updateBinaryStream(String columnLabel, InputStream x)
1669: throws SQLException {
1670: throw new UnsupportedOperationException("Not supported yet.");
1671: }
1672:
1673: public void updateCharacterStream(String columnLabel, Reader reader)
1674: throws SQLException {
1675: throw new UnsupportedOperationException("Not supported yet.");
1676: }
1677:
1678: public void updateBlob(int columnIndex, InputStream inputStream)
1679: throws SQLException {
1680: throw new UnsupportedOperationException("Not supported yet.");
1681: }
1682:
1683: public void updateBlob(String columnLabel, InputStream inputStream)
1684: throws SQLException {
1685: throw new UnsupportedOperationException("Not supported yet.");
1686: }
1687:
1688: public void updateClob(int columnIndex, Reader reader)
1689: throws SQLException {
1690: throw new UnsupportedOperationException("Not supported yet.");
1691: }
1692:
1693: public void updateClob(String columnLabel, Reader reader)
1694: throws SQLException {
1695: throw new UnsupportedOperationException("Not supported yet.");
1696: }
1697:
1698: public void updateNClob(int columnIndex, Reader reader)
1699: throws SQLException {
1700: throw new UnsupportedOperationException("Not supported yet.");
1701: }
1702:
1703: public void updateNClob(String columnLabel, Reader reader)
1704: throws SQLException {
1705: throw new UnsupportedOperationException("Not supported yet.");
1706: }
1707:
1708: public <T> T unwrap(Class<T> iface) throws SQLException {
1709: throw new UnsupportedOperationException("Not supported yet.");
1710: }
1711:
1712: public boolean isWrapperFor(Class<?> iface) throws SQLException {
1713: throw new UnsupportedOperationException("Not supported yet.");
1714: }
1715: }
|