0001: /*
0002: * Copyright (c) 1998-2005 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 class CallableStatementWrapper implements CallableStatement {
0040: private final CallableStatement _callableStatement;
0041: private final ProfilerPoint _profilerPoint;
0042:
0043: public CallableStatementWrapper(ProfilerPoint profilerPoint,
0044: CallableStatement callableStatement) {
0045: _profilerPoint = profilerPoint;
0046: _callableStatement = callableStatement;
0047: }
0048:
0049: public void registerOutParameter(int parameterIndex, int sqlType)
0050: throws SQLException {
0051: Profiler profiler = _profilerPoint.start();
0052:
0053: try {
0054: _callableStatement.registerOutParameter(parameterIndex,
0055: sqlType);
0056: } finally {
0057: profiler.finish();
0058: }
0059: }
0060:
0061: public void registerOutParameter(int parameterIndex, int sqlType,
0062: int scale) throws SQLException {
0063: Profiler profiler = _profilerPoint.start();
0064:
0065: try {
0066: _callableStatement.registerOutParameter(parameterIndex,
0067: sqlType, scale);
0068: } finally {
0069: profiler.finish();
0070: }
0071: }
0072:
0073: public boolean wasNull() throws SQLException {
0074: Profiler profiler = _profilerPoint.start();
0075:
0076: try {
0077: return _callableStatement.wasNull();
0078: } finally {
0079: profiler.finish();
0080: }
0081: }
0082:
0083: public String getString(int parameterIndex) throws SQLException {
0084: Profiler profiler = _profilerPoint.start();
0085:
0086: try {
0087: return _callableStatement.getString(parameterIndex);
0088: } finally {
0089: profiler.finish();
0090: }
0091: }
0092:
0093: public boolean getBoolean(int parameterIndex) throws SQLException {
0094: Profiler profiler = _profilerPoint.start();
0095:
0096: try {
0097: return _callableStatement.getBoolean(parameterIndex);
0098: } finally {
0099: profiler.finish();
0100: }
0101: }
0102:
0103: public byte getByte(int parameterIndex) throws SQLException {
0104: Profiler profiler = _profilerPoint.start();
0105:
0106: try {
0107: return _callableStatement.getByte(parameterIndex);
0108: } finally {
0109: profiler.finish();
0110: }
0111: }
0112:
0113: public short getShort(int parameterIndex) throws SQLException {
0114: Profiler profiler = _profilerPoint.start();
0115:
0116: try {
0117: return _callableStatement.getShort(parameterIndex);
0118: } finally {
0119: profiler.finish();
0120: }
0121: }
0122:
0123: public int getInt(int parameterIndex) throws SQLException {
0124: Profiler profiler = _profilerPoint.start();
0125:
0126: try {
0127: return _callableStatement.getInt(parameterIndex);
0128: } finally {
0129: profiler.finish();
0130: }
0131: }
0132:
0133: public long getLong(int parameterIndex) throws SQLException {
0134: Profiler profiler = _profilerPoint.start();
0135:
0136: try {
0137: return _callableStatement.getLong(parameterIndex);
0138: } finally {
0139: profiler.finish();
0140: }
0141: }
0142:
0143: public float getFloat(int parameterIndex) throws SQLException {
0144: Profiler profiler = _profilerPoint.start();
0145:
0146: try {
0147: return _callableStatement.getFloat(parameterIndex);
0148: } finally {
0149: profiler.finish();
0150: }
0151: }
0152:
0153: public double getDouble(int parameterIndex) throws SQLException {
0154: Profiler profiler = _profilerPoint.start();
0155:
0156: try {
0157: return _callableStatement.getDouble(parameterIndex);
0158: } finally {
0159: profiler.finish();
0160: }
0161: }
0162:
0163: public BigDecimal getBigDecimal(int parameterIndex, int scale)
0164: throws SQLException {
0165: Profiler profiler = _profilerPoint.start();
0166:
0167: try {
0168: return _callableStatement.getBigDecimal(parameterIndex,
0169: scale);
0170: } finally {
0171: profiler.finish();
0172: }
0173: }
0174:
0175: public byte[] getBytes(int parameterIndex) throws SQLException {
0176: Profiler profiler = _profilerPoint.start();
0177:
0178: try {
0179: return _callableStatement.getBytes(parameterIndex);
0180: } finally {
0181: profiler.finish();
0182: }
0183: }
0184:
0185: public Date getDate(int parameterIndex) throws SQLException {
0186: Profiler profiler = _profilerPoint.start();
0187:
0188: try {
0189: return _callableStatement.getDate(parameterIndex);
0190: } finally {
0191: profiler.finish();
0192: }
0193: }
0194:
0195: public Time getTime(int parameterIndex) throws SQLException {
0196: Profiler profiler = _profilerPoint.start();
0197:
0198: try {
0199: return _callableStatement.getTime(parameterIndex);
0200: } finally {
0201: profiler.finish();
0202: }
0203: }
0204:
0205: public Timestamp getTimestamp(int parameterIndex)
0206: throws SQLException {
0207: Profiler profiler = _profilerPoint.start();
0208:
0209: try {
0210: return _callableStatement.getTimestamp(parameterIndex);
0211: } finally {
0212: profiler.finish();
0213: }
0214: }
0215:
0216: public Object getObject(int parameterIndex) throws SQLException {
0217: Profiler profiler = _profilerPoint.start();
0218:
0219: try {
0220: return _callableStatement.getObject(parameterIndex);
0221: } finally {
0222: profiler.finish();
0223: }
0224: }
0225:
0226: public BigDecimal getBigDecimal(int parameterIndex)
0227: throws SQLException {
0228: Profiler profiler = _profilerPoint.start();
0229:
0230: try {
0231: return _callableStatement.getBigDecimal(parameterIndex);
0232: } finally {
0233: profiler.finish();
0234: }
0235: }
0236:
0237: public Object getObject(int i, Map<String, Class<?>> map)
0238: throws SQLException {
0239: Profiler profiler = _profilerPoint.start();
0240:
0241: try {
0242: return _callableStatement.getObject(i, map);
0243: } finally {
0244: profiler.finish();
0245: }
0246: }
0247:
0248: public Ref getRef(int i) throws SQLException {
0249: Profiler profiler = _profilerPoint.start();
0250:
0251: try {
0252: return _callableStatement.getRef(i);
0253: } finally {
0254: profiler.finish();
0255: }
0256: }
0257:
0258: public Blob getBlob(int i) throws SQLException {
0259: Profiler profiler = _profilerPoint.start();
0260:
0261: try {
0262: return _callableStatement.getBlob(i);
0263: } finally {
0264: profiler.finish();
0265: }
0266: }
0267:
0268: public Clob getClob(int i) throws SQLException {
0269: Profiler profiler = _profilerPoint.start();
0270:
0271: try {
0272: return _callableStatement.getClob(i);
0273: } finally {
0274: profiler.finish();
0275: }
0276: }
0277:
0278: public Array getArray(int i) throws SQLException {
0279: Profiler profiler = _profilerPoint.start();
0280:
0281: try {
0282: return _callableStatement.getArray(i);
0283: } finally {
0284: profiler.finish();
0285: }
0286: }
0287:
0288: public Date getDate(int parameterIndex, Calendar cal)
0289: throws SQLException {
0290: Profiler profiler = _profilerPoint.start();
0291:
0292: try {
0293: return _callableStatement.getDate(parameterIndex, cal);
0294: } finally {
0295: profiler.finish();
0296: }
0297: }
0298:
0299: public Time getTime(int parameterIndex, Calendar cal)
0300: throws SQLException {
0301: Profiler profiler = _profilerPoint.start();
0302:
0303: try {
0304: return _callableStatement.getTime(parameterIndex, cal);
0305: } finally {
0306: profiler.finish();
0307: }
0308: }
0309:
0310: public Timestamp getTimestamp(int parameterIndex, Calendar cal)
0311: throws SQLException {
0312: Profiler profiler = _profilerPoint.start();
0313:
0314: try {
0315: return _callableStatement.getTimestamp(parameterIndex, cal);
0316: } finally {
0317: profiler.finish();
0318: }
0319: }
0320:
0321: public void registerOutParameter(int paramIndex, int sqlType,
0322: String typeName) throws SQLException {
0323: Profiler profiler = _profilerPoint.start();
0324:
0325: try {
0326: _callableStatement.registerOutParameter(paramIndex,
0327: sqlType, typeName);
0328: } finally {
0329: profiler.finish();
0330: }
0331: }
0332:
0333: public void registerOutParameter(String parameterName, int sqlType)
0334: throws SQLException {
0335: Profiler profiler = _profilerPoint.start();
0336:
0337: try {
0338: _callableStatement.registerOutParameter(parameterName,
0339: sqlType);
0340: } finally {
0341: profiler.finish();
0342: }
0343: }
0344:
0345: public void registerOutParameter(String parameterName, int sqlType,
0346: int scale) throws SQLException {
0347: Profiler profiler = _profilerPoint.start();
0348:
0349: try {
0350: _callableStatement.registerOutParameter(parameterName,
0351: sqlType, scale);
0352: } finally {
0353: profiler.finish();
0354: }
0355: }
0356:
0357: public void registerOutParameter(String parameterName, int sqlType,
0358: String typeName) throws SQLException {
0359: Profiler profiler = _profilerPoint.start();
0360:
0361: try {
0362: _callableStatement.registerOutParameter(parameterName,
0363: sqlType, typeName);
0364: } finally {
0365: profiler.finish();
0366: }
0367: }
0368:
0369: public URL getURL(int parameterIndex) throws SQLException {
0370: Profiler profiler = _profilerPoint.start();
0371:
0372: try {
0373: return _callableStatement.getURL(parameterIndex);
0374: } finally {
0375: profiler.finish();
0376: }
0377: }
0378:
0379: public void setURL(String parameterName, URL val)
0380: throws SQLException {
0381: Profiler profiler = _profilerPoint.start();
0382:
0383: try {
0384: _callableStatement.setURL(parameterName, val);
0385: } finally {
0386: profiler.finish();
0387: }
0388: }
0389:
0390: public void setNull(String parameterName, int sqlType)
0391: throws SQLException {
0392: Profiler profiler = _profilerPoint.start();
0393:
0394: try {
0395: _callableStatement.setNull(parameterName, sqlType);
0396: } finally {
0397: profiler.finish();
0398: }
0399: }
0400:
0401: public void setBoolean(String parameterName, boolean x)
0402: throws SQLException {
0403: Profiler profiler = _profilerPoint.start();
0404:
0405: try {
0406: _callableStatement.setBoolean(parameterName, x);
0407: } finally {
0408: profiler.finish();
0409: }
0410: }
0411:
0412: public void setByte(String parameterName, byte x)
0413: throws SQLException {
0414: Profiler profiler = _profilerPoint.start();
0415:
0416: try {
0417: _callableStatement.setByte(parameterName, x);
0418: } finally {
0419: profiler.finish();
0420: }
0421: }
0422:
0423: public void setShort(String parameterName, short x)
0424: throws SQLException {
0425: Profiler profiler = _profilerPoint.start();
0426:
0427: try {
0428: _callableStatement.setShort(parameterName, x);
0429: } finally {
0430: profiler.finish();
0431: }
0432: }
0433:
0434: public void setInt(String parameterName, int x) throws SQLException {
0435: Profiler profiler = _profilerPoint.start();
0436:
0437: try {
0438: _callableStatement.setInt(parameterName, x);
0439: } finally {
0440: profiler.finish();
0441: }
0442: }
0443:
0444: public void setLong(String parameterName, long x)
0445: throws SQLException {
0446: Profiler profiler = _profilerPoint.start();
0447:
0448: try {
0449: _callableStatement.setLong(parameterName, x);
0450: } finally {
0451: profiler.finish();
0452: }
0453: }
0454:
0455: public void setFloat(String parameterName, float x)
0456: throws SQLException {
0457: Profiler profiler = _profilerPoint.start();
0458:
0459: try {
0460: _callableStatement.setFloat(parameterName, x);
0461: } finally {
0462: profiler.finish();
0463: }
0464: }
0465:
0466: public void setDouble(String parameterName, double x)
0467: throws SQLException {
0468: Profiler profiler = _profilerPoint.start();
0469:
0470: try {
0471: _callableStatement.setDouble(parameterName, x);
0472: } finally {
0473: profiler.finish();
0474: }
0475: }
0476:
0477: public void setBigDecimal(String parameterName, BigDecimal x)
0478: throws SQLException {
0479: Profiler profiler = _profilerPoint.start();
0480:
0481: try {
0482: _callableStatement.setBigDecimal(parameterName, x);
0483: } finally {
0484: profiler.finish();
0485: }
0486: }
0487:
0488: public void setString(String parameterName, String x)
0489: throws SQLException {
0490: Profiler profiler = _profilerPoint.start();
0491:
0492: try {
0493: _callableStatement.setString(parameterName, x);
0494: } finally {
0495: profiler.finish();
0496: }
0497: }
0498:
0499: public void setBytes(String parameterName, byte[] x)
0500: throws SQLException {
0501: Profiler profiler = _profilerPoint.start();
0502:
0503: try {
0504: _callableStatement.setBytes(parameterName, x);
0505: } finally {
0506: profiler.finish();
0507: }
0508: }
0509:
0510: public void setDate(String parameterName, Date x)
0511: throws SQLException {
0512: Profiler profiler = _profilerPoint.start();
0513:
0514: try {
0515: _callableStatement.setDate(parameterName, x);
0516: } finally {
0517: profiler.finish();
0518: }
0519: }
0520:
0521: public void setTime(String parameterName, Time x)
0522: throws SQLException {
0523: Profiler profiler = _profilerPoint.start();
0524:
0525: try {
0526: _callableStatement.setTime(parameterName, x);
0527: } finally {
0528: profiler.finish();
0529: }
0530: }
0531:
0532: public void setTimestamp(String parameterName, Timestamp x)
0533: throws SQLException {
0534: Profiler profiler = _profilerPoint.start();
0535:
0536: try {
0537: _callableStatement.setTimestamp(parameterName, x);
0538: } finally {
0539: profiler.finish();
0540: }
0541: }
0542:
0543: public void setAsciiStream(String parameterName, InputStream x,
0544: int length) throws SQLException {
0545: Profiler profiler = _profilerPoint.start();
0546:
0547: try {
0548: _callableStatement.setAsciiStream(parameterName, x, length);
0549: } finally {
0550: profiler.finish();
0551: }
0552: }
0553:
0554: public void setBinaryStream(String parameterName, InputStream x,
0555: int length) throws SQLException {
0556: Profiler profiler = _profilerPoint.start();
0557:
0558: try {
0559: _callableStatement
0560: .setBinaryStream(parameterName, x, length);
0561: } finally {
0562: profiler.finish();
0563: }
0564: }
0565:
0566: public void setObject(String parameterName, Object x,
0567: int targetSqlType, int scale) throws SQLException {
0568: Profiler profiler = _profilerPoint.start();
0569:
0570: try {
0571: _callableStatement.setObject(parameterName, x,
0572: targetSqlType, scale);
0573: } finally {
0574: profiler.finish();
0575: }
0576: }
0577:
0578: public void setObject(String parameterName, Object x,
0579: int targetSqlType) throws SQLException {
0580: Profiler profiler = _profilerPoint.start();
0581:
0582: try {
0583: _callableStatement.setObject(parameterName, x,
0584: targetSqlType);
0585: } finally {
0586: profiler.finish();
0587: }
0588: }
0589:
0590: public void setObject(String parameterName, Object x)
0591: throws SQLException {
0592: Profiler profiler = _profilerPoint.start();
0593:
0594: try {
0595: _callableStatement.setObject(parameterName, x);
0596: } finally {
0597: profiler.finish();
0598: }
0599: }
0600:
0601: public void setCharacterStream(String parameterName, Reader reader,
0602: int length) throws SQLException {
0603: Profiler profiler = _profilerPoint.start();
0604:
0605: try {
0606: _callableStatement.setCharacterStream(parameterName,
0607: reader, length);
0608: } finally {
0609: profiler.finish();
0610: }
0611: }
0612:
0613: public void setDate(String parameterName, Date x, Calendar cal)
0614: throws SQLException {
0615: Profiler profiler = _profilerPoint.start();
0616:
0617: try {
0618: _callableStatement.setDate(parameterName, x, cal);
0619: } finally {
0620: profiler.finish();
0621: }
0622: }
0623:
0624: public void setTime(String parameterName, Time x, Calendar cal)
0625: throws SQLException {
0626: Profiler profiler = _profilerPoint.start();
0627:
0628: try {
0629: _callableStatement.setTime(parameterName, x, cal);
0630: } finally {
0631: profiler.finish();
0632: }
0633: }
0634:
0635: public void setTimestamp(String parameterName, Timestamp x,
0636: Calendar cal) throws SQLException {
0637: Profiler profiler = _profilerPoint.start();
0638:
0639: try {
0640: _callableStatement.setTimestamp(parameterName, x, cal);
0641: } finally {
0642: profiler.finish();
0643: }
0644: }
0645:
0646: public void setNull(String parameterName, int sqlType,
0647: String typeName) throws SQLException {
0648: Profiler profiler = _profilerPoint.start();
0649:
0650: try {
0651: _callableStatement
0652: .setNull(parameterName, sqlType, typeName);
0653: } finally {
0654: profiler.finish();
0655: }
0656: }
0657:
0658: public String getString(String parameterName) throws SQLException {
0659: Profiler profiler = _profilerPoint.start();
0660:
0661: try {
0662: return _callableStatement.getString(parameterName);
0663: } finally {
0664: profiler.finish();
0665: }
0666: }
0667:
0668: public boolean getBoolean(String parameterName) throws SQLException {
0669: Profiler profiler = _profilerPoint.start();
0670:
0671: try {
0672: return _callableStatement.getBoolean(parameterName);
0673: } finally {
0674: profiler.finish();
0675: }
0676: }
0677:
0678: public byte getByte(String parameterName) throws SQLException {
0679: Profiler profiler = _profilerPoint.start();
0680:
0681: try {
0682: return _callableStatement.getByte(parameterName);
0683: } finally {
0684: profiler.finish();
0685: }
0686: }
0687:
0688: public short getShort(String parameterName) throws SQLException {
0689: Profiler profiler = _profilerPoint.start();
0690:
0691: try {
0692: return _callableStatement.getShort(parameterName);
0693: } finally {
0694: profiler.finish();
0695: }
0696: }
0697:
0698: public int getInt(String parameterName) throws SQLException {
0699: Profiler profiler = _profilerPoint.start();
0700:
0701: try {
0702: return _callableStatement.getInt(parameterName);
0703: } finally {
0704: profiler.finish();
0705: }
0706: }
0707:
0708: public long getLong(String parameterName) throws SQLException {
0709: Profiler profiler = _profilerPoint.start();
0710:
0711: try {
0712: return _callableStatement.getLong(parameterName);
0713: } finally {
0714: profiler.finish();
0715: }
0716: }
0717:
0718: public float getFloat(String parameterName) throws SQLException {
0719: Profiler profiler = _profilerPoint.start();
0720:
0721: try {
0722: return _callableStatement.getFloat(parameterName);
0723: } finally {
0724: profiler.finish();
0725: }
0726: }
0727:
0728: public double getDouble(String parameterName) throws SQLException {
0729: Profiler profiler = _profilerPoint.start();
0730:
0731: try {
0732: return _callableStatement.getDouble(parameterName);
0733: } finally {
0734: profiler.finish();
0735: }
0736: }
0737:
0738: public byte[] getBytes(String parameterName) throws SQLException {
0739: Profiler profiler = _profilerPoint.start();
0740:
0741: try {
0742: return _callableStatement.getBytes(parameterName);
0743: } finally {
0744: profiler.finish();
0745: }
0746: }
0747:
0748: public Date getDate(String parameterName) throws SQLException {
0749: Profiler profiler = _profilerPoint.start();
0750:
0751: try {
0752: return _callableStatement.getDate(parameterName);
0753: } finally {
0754: profiler.finish();
0755: }
0756: }
0757:
0758: public Time getTime(String parameterName) throws SQLException {
0759: Profiler profiler = _profilerPoint.start();
0760:
0761: try {
0762: return _callableStatement.getTime(parameterName);
0763: } finally {
0764: profiler.finish();
0765: }
0766: }
0767:
0768: public Timestamp getTimestamp(String parameterName)
0769: throws SQLException {
0770: Profiler profiler = _profilerPoint.start();
0771:
0772: try {
0773: return _callableStatement.getTimestamp(parameterName);
0774: } finally {
0775: profiler.finish();
0776: }
0777: }
0778:
0779: public Object getObject(String parameterName) throws SQLException {
0780: Profiler profiler = _profilerPoint.start();
0781:
0782: try {
0783: return _callableStatement.getObject(parameterName);
0784: } finally {
0785: profiler.finish();
0786: }
0787: }
0788:
0789: public BigDecimal getBigDecimal(String parameterName)
0790: throws SQLException {
0791: Profiler profiler = _profilerPoint.start();
0792:
0793: try {
0794: return _callableStatement.getBigDecimal(parameterName);
0795: } finally {
0796: profiler.finish();
0797: }
0798: }
0799:
0800: public Object getObject(String parameterName,
0801: Map<String, Class<?>> map) throws SQLException {
0802: Profiler profiler = _profilerPoint.start();
0803:
0804: try {
0805: return _callableStatement.getObject(parameterName, map);
0806: } finally {
0807: profiler.finish();
0808: }
0809: }
0810:
0811: public Ref getRef(String parameterName) throws SQLException {
0812: Profiler profiler = _profilerPoint.start();
0813:
0814: try {
0815: return _callableStatement.getRef(parameterName);
0816: } finally {
0817: profiler.finish();
0818: }
0819: }
0820:
0821: public Blob getBlob(String parameterName) throws SQLException {
0822: Profiler profiler = _profilerPoint.start();
0823:
0824: try {
0825: return _callableStatement.getBlob(parameterName);
0826: } finally {
0827: profiler.finish();
0828: }
0829: }
0830:
0831: public Clob getClob(String parameterName) throws SQLException {
0832: Profiler profiler = _profilerPoint.start();
0833:
0834: try {
0835: return _callableStatement.getClob(parameterName);
0836: } finally {
0837: profiler.finish();
0838: }
0839: }
0840:
0841: public Array getArray(String parameterName) throws SQLException {
0842: Profiler profiler = _profilerPoint.start();
0843:
0844: try {
0845: return _callableStatement.getArray(parameterName);
0846: } finally {
0847: profiler.finish();
0848: }
0849: }
0850:
0851: public Date getDate(String parameterName, Calendar cal)
0852: throws SQLException {
0853: Profiler profiler = _profilerPoint.start();
0854:
0855: try {
0856: return _callableStatement.getDate(parameterName, cal);
0857: } finally {
0858: profiler.finish();
0859: }
0860: }
0861:
0862: public Time getTime(String parameterName, Calendar cal)
0863: throws SQLException {
0864: Profiler profiler = _profilerPoint.start();
0865:
0866: try {
0867: return _callableStatement.getTime(parameterName, cal);
0868: } finally {
0869: profiler.finish();
0870: }
0871: }
0872:
0873: public Timestamp getTimestamp(String parameterName, Calendar cal)
0874: throws SQLException {
0875: Profiler profiler = _profilerPoint.start();
0876:
0877: try {
0878: return _callableStatement.getTimestamp(parameterName, cal);
0879: } finally {
0880: profiler.finish();
0881: }
0882: }
0883:
0884: public URL getURL(String parameterName) throws SQLException {
0885: Profiler profiler = _profilerPoint.start();
0886:
0887: try {
0888: return _callableStatement.getURL(parameterName);
0889: } finally {
0890: profiler.finish();
0891: }
0892: }
0893:
0894: public ResultSet executeQuery() throws SQLException {
0895: Profiler profiler = _profilerPoint.start();
0896:
0897: try {
0898: return _callableStatement.executeQuery();
0899: } finally {
0900: profiler.finish();
0901: }
0902: }
0903:
0904: public int executeUpdate() throws SQLException {
0905: Profiler profiler = _profilerPoint.start();
0906:
0907: try {
0908: return _callableStatement.executeUpdate();
0909: } finally {
0910: profiler.finish();
0911: }
0912: }
0913:
0914: public void setNull(int parameterIndex, int sqlType)
0915: throws SQLException {
0916: Profiler profiler = _profilerPoint.start();
0917:
0918: try {
0919: _callableStatement.setNull(parameterIndex, sqlType);
0920: } finally {
0921: profiler.finish();
0922: }
0923: }
0924:
0925: public void setBoolean(int parameterIndex, boolean x)
0926: throws SQLException {
0927: Profiler profiler = _profilerPoint.start();
0928:
0929: try {
0930: _callableStatement.setBoolean(parameterIndex, x);
0931: } finally {
0932: profiler.finish();
0933: }
0934: }
0935:
0936: public void setByte(int parameterIndex, byte x) throws SQLException {
0937: Profiler profiler = _profilerPoint.start();
0938:
0939: try {
0940: _callableStatement.setByte(parameterIndex, x);
0941: } finally {
0942: profiler.finish();
0943: }
0944: }
0945:
0946: public void setShort(int parameterIndex, short x)
0947: throws SQLException {
0948: Profiler profiler = _profilerPoint.start();
0949:
0950: try {
0951: _callableStatement.setShort(parameterIndex, x);
0952: } finally {
0953: profiler.finish();
0954: }
0955: }
0956:
0957: public void setInt(int parameterIndex, int x) throws SQLException {
0958: Profiler profiler = _profilerPoint.start();
0959:
0960: try {
0961: _callableStatement.setInt(parameterIndex, x);
0962: } finally {
0963: profiler.finish();
0964: }
0965: }
0966:
0967: public void setLong(int parameterIndex, long x) throws SQLException {
0968: Profiler profiler = _profilerPoint.start();
0969:
0970: try {
0971: _callableStatement.setLong(parameterIndex, x);
0972: } finally {
0973: profiler.finish();
0974: }
0975: }
0976:
0977: public void setFloat(int parameterIndex, float x)
0978: throws SQLException {
0979: Profiler profiler = _profilerPoint.start();
0980:
0981: try {
0982: _callableStatement.setFloat(parameterIndex, x);
0983: } finally {
0984: profiler.finish();
0985: }
0986: }
0987:
0988: public void setDouble(int parameterIndex, double x)
0989: throws SQLException {
0990: Profiler profiler = _profilerPoint.start();
0991:
0992: try {
0993: _callableStatement.setDouble(parameterIndex, x);
0994: } finally {
0995: profiler.finish();
0996: }
0997: }
0998:
0999: public void setBigDecimal(int parameterIndex, BigDecimal x)
1000: throws SQLException {
1001: Profiler profiler = _profilerPoint.start();
1002:
1003: try {
1004: _callableStatement.setBigDecimal(parameterIndex, x);
1005: } finally {
1006: profiler.finish();
1007: }
1008: }
1009:
1010: public void setString(int parameterIndex, String x)
1011: throws SQLException {
1012: Profiler profiler = _profilerPoint.start();
1013:
1014: try {
1015: _callableStatement.setString(parameterIndex, x);
1016: } finally {
1017: profiler.finish();
1018: }
1019: }
1020:
1021: public void setBytes(int parameterIndex, byte[] x)
1022: throws SQLException {
1023: Profiler profiler = _profilerPoint.start();
1024:
1025: try {
1026: _callableStatement.setBytes(parameterIndex, x);
1027: } finally {
1028: profiler.finish();
1029: }
1030: }
1031:
1032: public void setDate(int parameterIndex, Date x) throws SQLException {
1033: Profiler profiler = _profilerPoint.start();
1034:
1035: try {
1036: _callableStatement.setDate(parameterIndex, x);
1037: } finally {
1038: profiler.finish();
1039: }
1040: }
1041:
1042: public void setTime(int parameterIndex, Time x) throws SQLException {
1043: Profiler profiler = _profilerPoint.start();
1044:
1045: try {
1046: _callableStatement.setTime(parameterIndex, x);
1047: } finally {
1048: profiler.finish();
1049: }
1050: }
1051:
1052: public void setTimestamp(int parameterIndex, Timestamp x)
1053: throws SQLException {
1054: Profiler profiler = _profilerPoint.start();
1055:
1056: try {
1057: _callableStatement.setTimestamp(parameterIndex, x);
1058: } finally {
1059: profiler.finish();
1060: }
1061: }
1062:
1063: public void setAsciiStream(int parameterIndex, InputStream x,
1064: int length) throws SQLException {
1065: Profiler profiler = _profilerPoint.start();
1066:
1067: try {
1068: _callableStatement
1069: .setAsciiStream(parameterIndex, x, length);
1070: } finally {
1071: profiler.finish();
1072: }
1073: }
1074:
1075: public void setUnicodeStream(int parameterIndex, InputStream x,
1076: int length) throws SQLException {
1077: Profiler profiler = _profilerPoint.start();
1078:
1079: try {
1080: _callableStatement.setUnicodeStream(parameterIndex, x,
1081: length);
1082: } finally {
1083: profiler.finish();
1084: }
1085: }
1086:
1087: public void setBinaryStream(int parameterIndex, InputStream x,
1088: int length) throws SQLException {
1089: Profiler profiler = _profilerPoint.start();
1090:
1091: try {
1092: _callableStatement.setBinaryStream(parameterIndex, x,
1093: length);
1094: } finally {
1095: profiler.finish();
1096: }
1097: }
1098:
1099: public void clearParameters() throws SQLException {
1100: Profiler profiler = _profilerPoint.start();
1101:
1102: try {
1103: _callableStatement.clearParameters();
1104: } finally {
1105: profiler.finish();
1106: }
1107: }
1108:
1109: public void setObject(int parameterIndex, Object x,
1110: int targetSqlType, int scale) throws SQLException {
1111: Profiler profiler = _profilerPoint.start();
1112:
1113: try {
1114: _callableStatement.setObject(parameterIndex, x,
1115: targetSqlType, scale);
1116: } finally {
1117: profiler.finish();
1118: }
1119: }
1120:
1121: public void setObject(int parameterIndex, Object x,
1122: int targetSqlType) throws SQLException {
1123: Profiler profiler = _profilerPoint.start();
1124:
1125: try {
1126: _callableStatement.setObject(parameterIndex, x,
1127: targetSqlType);
1128: } finally {
1129: profiler.finish();
1130: }
1131: }
1132:
1133: public void setObject(int parameterIndex, Object x)
1134: throws SQLException {
1135: Profiler profiler = _profilerPoint.start();
1136:
1137: try {
1138: _callableStatement.setObject(parameterIndex, x);
1139: } finally {
1140: profiler.finish();
1141: }
1142: }
1143:
1144: public boolean execute() throws SQLException {
1145: Profiler profiler = _profilerPoint.start();
1146:
1147: try {
1148: return _callableStatement.execute();
1149: } finally {
1150: profiler.finish();
1151: }
1152: }
1153:
1154: public void addBatch() throws SQLException {
1155: Profiler profiler = _profilerPoint.start();
1156:
1157: try {
1158: _callableStatement.addBatch();
1159: } finally {
1160: profiler.finish();
1161: }
1162: }
1163:
1164: public void setCharacterStream(int parameterIndex, Reader reader,
1165: int length) throws SQLException {
1166: Profiler profiler = _profilerPoint.start();
1167:
1168: try {
1169: _callableStatement.setCharacterStream(parameterIndex,
1170: reader, length);
1171: } finally {
1172: profiler.finish();
1173: }
1174: }
1175:
1176: public void setRef(int i, Ref x) throws SQLException {
1177: Profiler profiler = _profilerPoint.start();
1178:
1179: try {
1180: _callableStatement.setRef(i, x);
1181: } finally {
1182: profiler.finish();
1183: }
1184: }
1185:
1186: public void setBlob(int i, Blob x) throws SQLException {
1187: Profiler profiler = _profilerPoint.start();
1188:
1189: try {
1190: _callableStatement.setBlob(i, x);
1191: } finally {
1192: profiler.finish();
1193: }
1194: }
1195:
1196: public void setClob(int i, Clob x) throws SQLException {
1197: Profiler profiler = _profilerPoint.start();
1198:
1199: try {
1200: _callableStatement.setClob(i, x);
1201: } finally {
1202: profiler.finish();
1203: }
1204: }
1205:
1206: public void setArray(int i, Array x) throws SQLException {
1207: Profiler profiler = _profilerPoint.start();
1208:
1209: try {
1210: _callableStatement.setArray(i, x);
1211: } finally {
1212: profiler.finish();
1213: }
1214: }
1215:
1216: public ResultSetMetaData getMetaData() throws SQLException {
1217: Profiler profiler = _profilerPoint.start();
1218:
1219: try {
1220: return _callableStatement.getMetaData();
1221: } finally {
1222: profiler.finish();
1223: }
1224: }
1225:
1226: public void setDate(int parameterIndex, Date x, Calendar cal)
1227: throws SQLException {
1228: Profiler profiler = _profilerPoint.start();
1229:
1230: try {
1231: _callableStatement.setDate(parameterIndex, x, cal);
1232: } finally {
1233: profiler.finish();
1234: }
1235: }
1236:
1237: public void setTime(int parameterIndex, Time x, Calendar cal)
1238: throws SQLException {
1239: Profiler profiler = _profilerPoint.start();
1240:
1241: try {
1242: _callableStatement.setTime(parameterIndex, x, cal);
1243: } finally {
1244: profiler.finish();
1245: }
1246: }
1247:
1248: public void setTimestamp(int parameterIndex, Timestamp x,
1249: Calendar cal) throws SQLException {
1250: Profiler profiler = _profilerPoint.start();
1251:
1252: try {
1253: _callableStatement.setTimestamp(parameterIndex, x, cal);
1254: } finally {
1255: profiler.finish();
1256: }
1257: }
1258:
1259: public void setNull(int paramIndex, int sqlType, String typeName)
1260: throws SQLException {
1261: Profiler profiler = _profilerPoint.start();
1262:
1263: try {
1264: _callableStatement.setNull(paramIndex, sqlType, typeName);
1265: } finally {
1266: profiler.finish();
1267: }
1268: }
1269:
1270: public void setURL(int parameterIndex, URL x) throws SQLException {
1271: Profiler profiler = _profilerPoint.start();
1272:
1273: try {
1274: _callableStatement.setURL(parameterIndex, x);
1275: } finally {
1276: profiler.finish();
1277: }
1278: }
1279:
1280: public ParameterMetaData getParameterMetaData() throws SQLException {
1281: Profiler profiler = _profilerPoint.start();
1282:
1283: try {
1284: return _callableStatement.getParameterMetaData();
1285: } finally {
1286: profiler.finish();
1287: }
1288: }
1289:
1290: public ResultSet executeQuery(String sql) throws SQLException {
1291: Profiler profiler = _profilerPoint.start();
1292:
1293: try {
1294: return _callableStatement.executeQuery(sql);
1295: } finally {
1296: profiler.finish();
1297: }
1298: }
1299:
1300: public int executeUpdate(String sql) throws SQLException {
1301: Profiler profiler = _profilerPoint.start();
1302:
1303: try {
1304: return _callableStatement.executeUpdate(sql);
1305: } finally {
1306: profiler.finish();
1307: }
1308: }
1309:
1310: public void close() throws SQLException {
1311: Profiler profiler = _profilerPoint.start();
1312:
1313: try {
1314: _callableStatement.close();
1315: } finally {
1316: profiler.finish();
1317: }
1318: }
1319:
1320: public int getMaxFieldSize() throws SQLException {
1321: Profiler profiler = _profilerPoint.start();
1322:
1323: try {
1324: return _callableStatement.getMaxFieldSize();
1325: } finally {
1326: profiler.finish();
1327: }
1328: }
1329:
1330: public void setMaxFieldSize(int max) throws SQLException {
1331: Profiler profiler = _profilerPoint.start();
1332:
1333: try {
1334: _callableStatement.setMaxFieldSize(max);
1335: } finally {
1336: profiler.finish();
1337: }
1338: }
1339:
1340: public int getMaxRows() throws SQLException {
1341: Profiler profiler = _profilerPoint.start();
1342:
1343: try {
1344: return _callableStatement.getMaxRows();
1345: } finally {
1346: profiler.finish();
1347: }
1348: }
1349:
1350: public void setMaxRows(int max) throws SQLException {
1351: Profiler profiler = _profilerPoint.start();
1352:
1353: try {
1354: _callableStatement.setMaxRows(max);
1355: } finally {
1356: profiler.finish();
1357: }
1358: }
1359:
1360: public void setEscapeProcessing(boolean enable) throws SQLException {
1361: Profiler profiler = _profilerPoint.start();
1362:
1363: try {
1364: _callableStatement.setEscapeProcessing(enable);
1365: } finally {
1366: profiler.finish();
1367: }
1368: }
1369:
1370: public int getQueryTimeout() throws SQLException {
1371: Profiler profiler = _profilerPoint.start();
1372:
1373: try {
1374: return _callableStatement.getQueryTimeout();
1375: } finally {
1376: profiler.finish();
1377: }
1378: }
1379:
1380: public void setQueryTimeout(int seconds) throws SQLException {
1381: Profiler profiler = _profilerPoint.start();
1382:
1383: try {
1384: _callableStatement.setQueryTimeout(seconds);
1385: } finally {
1386: profiler.finish();
1387: }
1388: }
1389:
1390: public void cancel() throws SQLException {
1391: Profiler profiler = _profilerPoint.start();
1392:
1393: try {
1394: _callableStatement.cancel();
1395: } finally {
1396: profiler.finish();
1397: }
1398: }
1399:
1400: public SQLWarning getWarnings() throws SQLException {
1401: Profiler profiler = _profilerPoint.start();
1402:
1403: try {
1404: return _callableStatement.getWarnings();
1405: } finally {
1406: profiler.finish();
1407: }
1408: }
1409:
1410: public void clearWarnings() throws SQLException {
1411: Profiler profiler = _profilerPoint.start();
1412:
1413: try {
1414: _callableStatement.clearWarnings();
1415: } finally {
1416: profiler.finish();
1417: }
1418: }
1419:
1420: public void setCursorName(String name) throws SQLException {
1421: Profiler profiler = _profilerPoint.start();
1422:
1423: try {
1424: _callableStatement.setCursorName(name);
1425: } finally {
1426: profiler.finish();
1427: }
1428: }
1429:
1430: public boolean execute(String sql) throws SQLException {
1431: Profiler profiler = _profilerPoint.start();
1432:
1433: try {
1434: return _callableStatement.execute(sql);
1435: } finally {
1436: profiler.finish();
1437: }
1438: }
1439:
1440: public ResultSet getResultSet() throws SQLException {
1441: Profiler profiler = _profilerPoint.start();
1442:
1443: try {
1444: return _callableStatement.getResultSet();
1445: } finally {
1446: profiler.finish();
1447: }
1448: }
1449:
1450: public int getUpdateCount() throws SQLException {
1451: Profiler profiler = _profilerPoint.start();
1452:
1453: try {
1454: return _callableStatement.getUpdateCount();
1455: } finally {
1456: profiler.finish();
1457: }
1458: }
1459:
1460: public boolean getMoreResults() throws SQLException {
1461: Profiler profiler = _profilerPoint.start();
1462:
1463: try {
1464: return _callableStatement.getMoreResults();
1465: } finally {
1466: profiler.finish();
1467: }
1468: }
1469:
1470: public void setFetchDirection(int direction) throws SQLException {
1471: Profiler profiler = _profilerPoint.start();
1472:
1473: try {
1474: _callableStatement.setFetchDirection(direction);
1475: } finally {
1476: profiler.finish();
1477: }
1478: }
1479:
1480: public int getFetchDirection() throws SQLException {
1481: Profiler profiler = _profilerPoint.start();
1482:
1483: try {
1484: return _callableStatement.getFetchDirection();
1485: } finally {
1486: profiler.finish();
1487: }
1488: }
1489:
1490: public void setFetchSize(int rows) throws SQLException {
1491: Profiler profiler = _profilerPoint.start();
1492:
1493: try {
1494: _callableStatement.setFetchSize(rows);
1495: } finally {
1496: profiler.finish();
1497: }
1498: }
1499:
1500: public int getFetchSize() throws SQLException {
1501: Profiler profiler = _profilerPoint.start();
1502:
1503: try {
1504: return _callableStatement.getFetchSize();
1505: } finally {
1506: profiler.finish();
1507: }
1508: }
1509:
1510: public int getResultSetConcurrency() throws SQLException {
1511: Profiler profiler = _profilerPoint.start();
1512:
1513: try {
1514: return _callableStatement.getResultSetConcurrency();
1515: } finally {
1516: profiler.finish();
1517: }
1518: }
1519:
1520: public int getResultSetType() throws SQLException {
1521: Profiler profiler = _profilerPoint.start();
1522:
1523: try {
1524: return _callableStatement.getResultSetType();
1525: } finally {
1526: profiler.finish();
1527: }
1528: }
1529:
1530: public void addBatch(String sql) throws SQLException {
1531: Profiler profiler = _profilerPoint.start();
1532:
1533: try {
1534: _callableStatement.addBatch(sql);
1535: } finally {
1536: profiler.finish();
1537: }
1538: }
1539:
1540: public void clearBatch() throws SQLException {
1541: Profiler profiler = _profilerPoint.start();
1542:
1543: try {
1544: _callableStatement.clearBatch();
1545: } finally {
1546: profiler.finish();
1547: }
1548: }
1549:
1550: public int[] executeBatch() throws SQLException {
1551: Profiler profiler = _profilerPoint.start();
1552:
1553: try {
1554: return _callableStatement.executeBatch();
1555: } finally {
1556: profiler.finish();
1557: }
1558: }
1559:
1560: public Connection getConnection() throws SQLException {
1561: Profiler profiler = _profilerPoint.start();
1562:
1563: try {
1564: return _callableStatement.getConnection();
1565: } finally {
1566: profiler.finish();
1567: }
1568: }
1569:
1570: public boolean getMoreResults(int current) throws SQLException {
1571: Profiler profiler = _profilerPoint.start();
1572:
1573: try {
1574: return _callableStatement.getMoreResults(current);
1575: } finally {
1576: profiler.finish();
1577: }
1578: }
1579:
1580: public ResultSet getGeneratedKeys() throws SQLException {
1581: Profiler profiler = _profilerPoint.start();
1582:
1583: try {
1584: return _callableStatement.getGeneratedKeys();
1585: } finally {
1586: profiler.finish();
1587: }
1588: }
1589:
1590: public int executeUpdate(String sql, int autoGeneratedKeys)
1591: throws SQLException {
1592: Profiler profiler = _profilerPoint.start();
1593:
1594: try {
1595: return _callableStatement.executeUpdate(sql,
1596: autoGeneratedKeys);
1597: } finally {
1598: profiler.finish();
1599: }
1600: }
1601:
1602: public int executeUpdate(String sql, int[] columnIndexes)
1603: throws SQLException {
1604: Profiler profiler = _profilerPoint.start();
1605:
1606: try {
1607: return _callableStatement.executeUpdate(sql, columnIndexes);
1608: } finally {
1609: profiler.finish();
1610: }
1611: }
1612:
1613: public int executeUpdate(String sql, String[] columnNames)
1614: throws SQLException {
1615: Profiler profiler = _profilerPoint.start();
1616:
1617: try {
1618: return _callableStatement.executeUpdate(sql, columnNames);
1619: } finally {
1620: profiler.finish();
1621: }
1622: }
1623:
1624: public boolean execute(String sql, int autoGeneratedKeys)
1625: throws SQLException {
1626: Profiler profiler = _profilerPoint.start();
1627:
1628: try {
1629: return _callableStatement.execute(sql, autoGeneratedKeys);
1630: } finally {
1631: profiler.finish();
1632: }
1633: }
1634:
1635: public boolean execute(String sql, int[] columnIndexes)
1636: throws SQLException {
1637: Profiler profiler = _profilerPoint.start();
1638:
1639: try {
1640: return _callableStatement.execute(sql, columnIndexes);
1641: } finally {
1642: profiler.finish();
1643: }
1644: }
1645:
1646: public boolean execute(String sql, String[] columnNames)
1647: throws SQLException {
1648: Profiler profiler = _profilerPoint.start();
1649:
1650: try {
1651: return _callableStatement.execute(sql, columnNames);
1652: } finally {
1653: profiler.finish();
1654: }
1655: }
1656:
1657: public int getResultSetHoldability() throws SQLException {
1658: Profiler profiler = _profilerPoint.start();
1659:
1660: try {
1661: return _callableStatement.getResultSetHoldability();
1662: } finally {
1663: profiler.finish();
1664: }
1665: }
1666:
1667: public String toString() {
1668: return "CallableStatementWrapper[" + _profilerPoint.getName()
1669: + "]";
1670: }
1671:
1672: public RowId getRowId(int parameterIndex) throws SQLException {
1673: throw new UnsupportedOperationException("Not supported yet.");
1674: }
1675:
1676: public RowId getRowId(String parameterName) throws SQLException {
1677: throw new UnsupportedOperationException("Not supported yet.");
1678: }
1679:
1680: public void setRowId(String parameterName, RowId x)
1681: throws SQLException {
1682: throw new UnsupportedOperationException("Not supported yet.");
1683: }
1684:
1685: public void setNString(String parameterName, String value)
1686: throws SQLException {
1687: throw new UnsupportedOperationException("Not supported yet.");
1688: }
1689:
1690: public void setNCharacterStream(String parameterName, Reader value,
1691: long length) throws SQLException {
1692: throw new UnsupportedOperationException("Not supported yet.");
1693: }
1694:
1695: public void setNClob(String parameterName, NClob value)
1696: throws SQLException {
1697: throw new UnsupportedOperationException("Not supported yet.");
1698: }
1699:
1700: public void setClob(String parameterName, Reader reader, long length)
1701: throws SQLException {
1702: throw new UnsupportedOperationException("Not supported yet.");
1703: }
1704:
1705: public void setBlob(String parameterName, InputStream inputStream,
1706: long length) throws SQLException {
1707: throw new UnsupportedOperationException("Not supported yet.");
1708: }
1709:
1710: public void setNClob(String parameterName, Reader reader,
1711: long length) throws SQLException {
1712: throw new UnsupportedOperationException("Not supported yet.");
1713: }
1714:
1715: public NClob getNClob(int parameterIndex) throws SQLException {
1716: throw new UnsupportedOperationException("Not supported yet.");
1717: }
1718:
1719: public NClob getNClob(String parameterName) throws SQLException {
1720: throw new UnsupportedOperationException("Not supported yet.");
1721: }
1722:
1723: public void setSQLXML(String parameterName, SQLXML xmlObject)
1724: throws SQLException {
1725: throw new UnsupportedOperationException("Not supported yet.");
1726: }
1727:
1728: public SQLXML getSQLXML(int parameterIndex) throws SQLException {
1729: throw new UnsupportedOperationException("Not supported yet.");
1730: }
1731:
1732: public SQLXML getSQLXML(String parameterName) throws SQLException {
1733: throw new UnsupportedOperationException("Not supported yet.");
1734: }
1735:
1736: public String getNString(int parameterIndex) throws SQLException {
1737: throw new UnsupportedOperationException("Not supported yet.");
1738: }
1739:
1740: public String getNString(String parameterName) throws SQLException {
1741: throw new UnsupportedOperationException("Not supported yet.");
1742: }
1743:
1744: public Reader getNCharacterStream(int parameterIndex)
1745: throws SQLException {
1746: throw new UnsupportedOperationException("Not supported yet.");
1747: }
1748:
1749: public Reader getNCharacterStream(String parameterName)
1750: throws SQLException {
1751: throw new UnsupportedOperationException("Not supported yet.");
1752: }
1753:
1754: public Reader getCharacterStream(int parameterIndex)
1755: throws SQLException {
1756: throw new UnsupportedOperationException("Not supported yet.");
1757: }
1758:
1759: public Reader getCharacterStream(String parameterName)
1760: throws SQLException {
1761: throw new UnsupportedOperationException("Not supported yet.");
1762: }
1763:
1764: public void setBlob(String parameterName, Blob x)
1765: throws SQLException {
1766: throw new UnsupportedOperationException("Not supported yet.");
1767: }
1768:
1769: public void setClob(String parameterName, Clob x)
1770: throws SQLException {
1771: throw new UnsupportedOperationException("Not supported yet.");
1772: }
1773:
1774: public void setAsciiStream(String parameterName, InputStream x,
1775: long length) throws SQLException {
1776: throw new UnsupportedOperationException("Not supported yet.");
1777: }
1778:
1779: public void setBinaryStream(String parameterName, InputStream x,
1780: long length) throws SQLException {
1781: throw new UnsupportedOperationException("Not supported yet.");
1782: }
1783:
1784: public void setCharacterStream(String parameterName, Reader reader,
1785: long length) throws SQLException {
1786: throw new UnsupportedOperationException("Not supported yet.");
1787: }
1788:
1789: public void setAsciiStream(String parameterName, InputStream x)
1790: throws SQLException {
1791: throw new UnsupportedOperationException("Not supported yet.");
1792: }
1793:
1794: public void setBinaryStream(String parameterName, InputStream x)
1795: throws SQLException {
1796: throw new UnsupportedOperationException("Not supported yet.");
1797: }
1798:
1799: public void setCharacterStream(String parameterName, Reader reader)
1800: throws SQLException {
1801: throw new UnsupportedOperationException("Not supported yet.");
1802: }
1803:
1804: public void setNCharacterStream(String parameterName, Reader value)
1805: throws SQLException {
1806: throw new UnsupportedOperationException("Not supported yet.");
1807: }
1808:
1809: public void setClob(String parameterName, Reader reader)
1810: throws SQLException {
1811: throw new UnsupportedOperationException("Not supported yet.");
1812: }
1813:
1814: public void setBlob(String parameterName, InputStream inputStream)
1815: throws SQLException {
1816: throw new UnsupportedOperationException("Not supported yet.");
1817: }
1818:
1819: public void setNClob(String parameterName, Reader reader)
1820: throws SQLException {
1821: throw new UnsupportedOperationException("Not supported yet.");
1822: }
1823:
1824: public void setRowId(int parameterIndex, RowId x)
1825: throws SQLException {
1826: throw new UnsupportedOperationException("Not supported yet.");
1827: }
1828:
1829: public void setNString(int parameterIndex, String value)
1830: throws SQLException {
1831: throw new UnsupportedOperationException("Not supported yet.");
1832: }
1833:
1834: public void setNCharacterStream(int parameterIndex, Reader value,
1835: long length) throws SQLException {
1836: throw new UnsupportedOperationException("Not supported yet.");
1837: }
1838:
1839: public void setNClob(int parameterIndex, NClob value)
1840: throws SQLException {
1841: throw new UnsupportedOperationException("Not supported yet.");
1842: }
1843:
1844: public void setClob(int parameterIndex, Reader reader, long length)
1845: throws SQLException {
1846: throw new UnsupportedOperationException("Not supported yet.");
1847: }
1848:
1849: public void setBlob(int parameterIndex, InputStream inputStream,
1850: long length) throws SQLException {
1851: throw new UnsupportedOperationException("Not supported yet.");
1852: }
1853:
1854: public void setNClob(int parameterIndex, Reader reader, long length)
1855: throws SQLException {
1856: throw new UnsupportedOperationException("Not supported yet.");
1857: }
1858:
1859: public void setSQLXML(int parameterIndex, SQLXML xmlObject)
1860: throws SQLException {
1861: throw new UnsupportedOperationException("Not supported yet.");
1862: }
1863:
1864: public void setAsciiStream(int parameterIndex, InputStream x,
1865: long length) throws SQLException {
1866: throw new UnsupportedOperationException("Not supported yet.");
1867: }
1868:
1869: public void setBinaryStream(int parameterIndex, InputStream x,
1870: long length) throws SQLException {
1871: throw new UnsupportedOperationException("Not supported yet.");
1872: }
1873:
1874: public void setCharacterStream(int parameterIndex, Reader reader,
1875: long length) throws SQLException {
1876: throw new UnsupportedOperationException("Not supported yet.");
1877: }
1878:
1879: public void setAsciiStream(int parameterIndex, InputStream x)
1880: throws SQLException {
1881: throw new UnsupportedOperationException("Not supported yet.");
1882: }
1883:
1884: public void setBinaryStream(int parameterIndex, InputStream x)
1885: throws SQLException {
1886: throw new UnsupportedOperationException("Not supported yet.");
1887: }
1888:
1889: public void setCharacterStream(int parameterIndex, Reader reader)
1890: throws SQLException {
1891: throw new UnsupportedOperationException("Not supported yet.");
1892: }
1893:
1894: public void setNCharacterStream(int parameterIndex, Reader value)
1895: throws SQLException {
1896: throw new UnsupportedOperationException("Not supported yet.");
1897: }
1898:
1899: public void setClob(int parameterIndex, Reader reader)
1900: throws SQLException {
1901: throw new UnsupportedOperationException("Not supported yet.");
1902: }
1903:
1904: public void setBlob(int parameterIndex, InputStream inputStream)
1905: throws SQLException {
1906: throw new UnsupportedOperationException("Not supported yet.");
1907: }
1908:
1909: public void setNClob(int parameterIndex, Reader reader)
1910: throws SQLException {
1911: throw new UnsupportedOperationException("Not supported yet.");
1912: }
1913:
1914: public boolean isClosed() throws SQLException {
1915: throw new UnsupportedOperationException("Not supported yet.");
1916: }
1917:
1918: public void setPoolable(boolean poolable) throws SQLException {
1919: throw new UnsupportedOperationException("Not supported yet.");
1920: }
1921:
1922: public boolean isPoolable() throws SQLException {
1923: throw new UnsupportedOperationException("Not supported yet.");
1924: }
1925:
1926: public <T> T unwrap(Class<T> iface) throws SQLException {
1927: throw new UnsupportedOperationException("Not supported yet.");
1928: }
1929:
1930: public boolean isWrapperFor(Class<?> iface) throws SQLException {
1931: throw new UnsupportedOperationException("Not supported yet.");
1932: }
1933: }
|