0001: // jTDS JDBC Driver for Microsoft SQL Server and Sybase
0002: // Copyright (C) 2004 The jTDS Project
0003: //
0004: // This library is free software; you can redistribute it and/or
0005: // modify it under the terms of the GNU Lesser General Public
0006: // License as published by the Free Software Foundation; either
0007: // version 2.1 of the License, or (at your option) any later version.
0008: //
0009: // This library is distributed in the hope that it will be useful,
0010: // but WITHOUT ANY WARRANTY; without even the implied warranty of
0011: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0012: // Lesser General Public License for more details.
0013: //
0014: // You should have received a copy of the GNU Lesser General Public
0015: // License along with this library; if not, write to the Free Software
0016: // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0017: //
0018: package net.sourceforge.jtds.jdbcx.proxy;
0019:
0020: import java.math.BigDecimal;
0021: import java.sql.*;
0022: import java.util.Calendar;
0023:
0024: import net.sourceforge.jtds.jdbc.*;
0025:
0026: /**
0027: * This class would be better implemented as a java.lang.reflect.Proxy. However, this
0028: * feature was not added until 1.3 and reflection performance was not improved until 1.4.
0029: * Since the driver still needs to be compatible with 1.2 and 1.3 this class is used
0030: * to delegate the calls to a callable statement with minimal overhead.
0031: *
0032: * @version $Id: CallableStatementProxy.java,v 1.3 2004/08/24 17:45:08 bheineman Exp $
0033: */
0034: public class CallableStatementProxy extends PreparedStatementProxy
0035: implements CallableStatement {
0036: private JtdsCallableStatement _callableStatement;
0037:
0038: CallableStatementProxy(ConnectionProxy connection,
0039: JtdsCallableStatement callableStatement) {
0040: super (connection, callableStatement);
0041:
0042: _callableStatement = callableStatement;
0043: }
0044:
0045: /**
0046: * Delgates calls to the callable statement; SQLExceptions thrown from the
0047: * callable statement will cause an event to be fired on the connection
0048: * pool listeners.
0049: *
0050: * @throws SQLException if an error occurs
0051: */
0052: public void registerOutParameter(int parameterIndex, int sqlType)
0053: throws SQLException {
0054: validateConnection();
0055:
0056: try {
0057: _callableStatement.registerOutParameter(parameterIndex,
0058: sqlType);
0059: } catch (SQLException sqlException) {
0060: processSQLException(sqlException);
0061: }
0062: }
0063:
0064: /**
0065: * Delgates calls to the callable statement; SQLExceptions thrown from the
0066: * callable statement will cause an event to be fired on the connection
0067: * pool listeners.
0068: *
0069: * @throws SQLException if an error occurs
0070: */
0071: public void registerOutParameter(int parameterIndex, int sqlType,
0072: int scale) throws SQLException {
0073: validateConnection();
0074:
0075: try {
0076: _callableStatement.registerOutParameter(parameterIndex,
0077: sqlType, scale);
0078: } catch (SQLException sqlException) {
0079: processSQLException(sqlException);
0080: }
0081: }
0082:
0083: /**
0084: * Delgates calls to the callable statement; SQLExceptions thrown from the
0085: * callable statement will cause an event to be fired on the connection
0086: * pool listeners.
0087: *
0088: * @throws SQLException if an error occurs
0089: */
0090: public boolean wasNull() throws SQLException {
0091: validateConnection();
0092:
0093: try {
0094: return _callableStatement.wasNull();
0095: } catch (SQLException sqlException) {
0096: processSQLException(sqlException);
0097: }
0098:
0099: return false;
0100: }
0101:
0102: /**
0103: * Delgates calls to the callable statement; SQLExceptions thrown from the
0104: * callable statement will cause an event to be fired on the connection
0105: * pool listeners.
0106: *
0107: * @throws SQLException if an error occurs
0108: */
0109: public String getString(int parameterIndex) throws SQLException {
0110: validateConnection();
0111:
0112: try {
0113: return _callableStatement.getString(parameterIndex);
0114: } catch (SQLException sqlException) {
0115: processSQLException(sqlException);
0116: }
0117:
0118: return null;
0119: }
0120:
0121: /**
0122: * Delgates calls to the callable statement; SQLExceptions thrown from the
0123: * callable statement will cause an event to be fired on the connection
0124: * pool listeners.
0125: *
0126: * @throws SQLException if an error occurs
0127: */
0128: public boolean getBoolean(int parameterIndex) throws SQLException {
0129: validateConnection();
0130:
0131: try {
0132: return _callableStatement.getBoolean(parameterIndex);
0133: } catch (SQLException sqlException) {
0134: processSQLException(sqlException);
0135: }
0136:
0137: return false;
0138: }
0139:
0140: /**
0141: * Delgates calls to the callable statement; SQLExceptions thrown from the
0142: * callable statement will cause an event to be fired on the connection
0143: * pool listeners.
0144: *
0145: * @throws SQLException if an error occurs
0146: */
0147: public byte getByte(int parameterIndex) throws SQLException {
0148: validateConnection();
0149:
0150: try {
0151: return _callableStatement.getByte(parameterIndex);
0152: } catch (SQLException sqlException) {
0153: processSQLException(sqlException);
0154: }
0155:
0156: return Byte.MIN_VALUE;
0157: }
0158:
0159: /**
0160: * Delgates calls to the callable statement; SQLExceptions thrown from the
0161: * callable statement will cause an event to be fired on the connection
0162: * pool listeners.
0163: *
0164: * @throws SQLException if an error occurs
0165: */
0166: public short getShort(int parameterIndex) throws SQLException {
0167: validateConnection();
0168:
0169: try {
0170: return _callableStatement.getShort(parameterIndex);
0171: } catch (SQLException sqlException) {
0172: processSQLException(sqlException);
0173: }
0174:
0175: return Short.MIN_VALUE;
0176: }
0177:
0178: /**
0179: * Delgates calls to the callable statement; SQLExceptions thrown from the
0180: * callable statement will cause an event to be fired on the connection
0181: * pool listeners.
0182: *
0183: * @throws SQLException if an error occurs
0184: */
0185: public int getInt(int parameterIndex) throws SQLException {
0186: validateConnection();
0187:
0188: try {
0189: return _callableStatement.getInt(parameterIndex);
0190: } catch (SQLException sqlException) {
0191: processSQLException(sqlException);
0192: }
0193:
0194: return Integer.MIN_VALUE;
0195: }
0196:
0197: /**
0198: * Delgates calls to the callable statement; SQLExceptions thrown from the
0199: * callable statement will cause an event to be fired on the connection
0200: * pool listeners.
0201: *
0202: * @throws SQLException if an error occurs
0203: */
0204: public long getLong(int parameterIndex) throws SQLException {
0205: validateConnection();
0206:
0207: try {
0208: return _callableStatement.getLong(parameterIndex);
0209: } catch (SQLException sqlException) {
0210: processSQLException(sqlException);
0211: }
0212:
0213: return Long.MIN_VALUE;
0214: }
0215:
0216: /**
0217: * Delgates calls to the callable statement; SQLExceptions thrown from the
0218: * callable statement will cause an event to be fired on the connection
0219: * pool listeners.
0220: *
0221: * @throws SQLException if an error occurs
0222: */
0223: public float getFloat(int parameterIndex) throws SQLException {
0224: validateConnection();
0225:
0226: try {
0227: return _callableStatement.getFloat(parameterIndex);
0228: } catch (SQLException sqlException) {
0229: processSQLException(sqlException);
0230: }
0231:
0232: return Float.MIN_VALUE;
0233: }
0234:
0235: /**
0236: * Delgates calls to the callable statement; SQLExceptions thrown from the
0237: * callable statement will cause an event to be fired on the connection
0238: * pool listeners.
0239: *
0240: * @throws SQLException if an error occurs
0241: */
0242: public double getDouble(int parameterIndex) throws SQLException {
0243: validateConnection();
0244:
0245: try {
0246: return _callableStatement.getDouble(parameterIndex);
0247: } catch (SQLException sqlException) {
0248: processSQLException(sqlException);
0249: }
0250:
0251: return Double.MIN_VALUE;
0252: }
0253:
0254: /**
0255: * Delgates calls to the callable statement; SQLExceptions thrown from the
0256: * callable statement will cause an event to be fired on the connection
0257: * pool listeners.
0258: *
0259: * @throws SQLException if an error occurs
0260: */
0261: public BigDecimal getBigDecimal(int parameterIndex, int scale)
0262: throws SQLException {
0263: validateConnection();
0264:
0265: try {
0266: return _callableStatement.getBigDecimal(parameterIndex,
0267: scale);
0268: } catch (SQLException sqlException) {
0269: processSQLException(sqlException);
0270: }
0271:
0272: return null;
0273: }
0274:
0275: /**
0276: * Delgates calls to the callable statement; SQLExceptions thrown from the
0277: * callable statement will cause an event to be fired on the connection
0278: * pool listeners.
0279: *
0280: * @throws SQLException if an error occurs
0281: */
0282: public byte[] getBytes(int parameterIndex) throws SQLException {
0283: validateConnection();
0284:
0285: try {
0286: return _callableStatement.getBytes(parameterIndex);
0287: } catch (SQLException sqlException) {
0288: processSQLException(sqlException);
0289: }
0290:
0291: return null;
0292: }
0293:
0294: /**
0295: * Delgates calls to the callable statement; SQLExceptions thrown from the
0296: * callable statement will cause an event to be fired on the connection
0297: * pool listeners.
0298: *
0299: * @throws SQLException if an error occurs
0300: */
0301: public Date getDate(int parameterIndex) throws SQLException {
0302: validateConnection();
0303:
0304: try {
0305: return _callableStatement.getDate(parameterIndex);
0306: } catch (SQLException sqlException) {
0307: processSQLException(sqlException);
0308: }
0309:
0310: return null;
0311: }
0312:
0313: /**
0314: * Delgates calls to the callable statement; SQLExceptions thrown from the
0315: * callable statement will cause an event to be fired on the connection
0316: * pool listeners.
0317: *
0318: * @throws SQLException if an error occurs
0319: */
0320: public Time getTime(int parameterIndex) throws SQLException {
0321: validateConnection();
0322:
0323: try {
0324: return _callableStatement.getTime(parameterIndex);
0325: } catch (SQLException sqlException) {
0326: processSQLException(sqlException);
0327: }
0328:
0329: return null;
0330: }
0331:
0332: /**
0333: * Delgates calls to the callable statement; SQLExceptions thrown from the
0334: * callable statement will cause an event to be fired on the connection
0335: * pool listeners.
0336: *
0337: * @throws SQLException if an error occurs
0338: */
0339: public Timestamp getTimestamp(int parameterIndex)
0340: throws SQLException {
0341: validateConnection();
0342:
0343: try {
0344: return _callableStatement.getTimestamp(parameterIndex);
0345: } catch (SQLException sqlException) {
0346: processSQLException(sqlException);
0347: }
0348:
0349: return null;
0350: }
0351:
0352: /**
0353: * Delgates calls to the callable statement; SQLExceptions thrown from the
0354: * callable statement will cause an event to be fired on the connection
0355: * pool listeners.
0356: *
0357: * @throws SQLException if an error occurs
0358: */
0359: public Object getObject(int parameterIndex) throws SQLException {
0360: validateConnection();
0361:
0362: try {
0363: return _callableStatement.getObject(parameterIndex);
0364: } catch (SQLException sqlException) {
0365: processSQLException(sqlException);
0366: }
0367:
0368: return null;
0369: }
0370:
0371: /**
0372: * Delgates calls to the callable statement; SQLExceptions thrown from the
0373: * callable statement will cause an event to be fired on the connection
0374: * pool listeners.
0375: *
0376: * @throws SQLException if an error occurs
0377: */
0378: public BigDecimal getBigDecimal(int parameterIndex)
0379: throws SQLException {
0380: validateConnection();
0381:
0382: try {
0383: return _callableStatement.getBigDecimal(parameterIndex);
0384: } catch (SQLException sqlException) {
0385: processSQLException(sqlException);
0386: }
0387:
0388: return null;
0389: }
0390:
0391: /**
0392: * Delgates calls to the callable statement; SQLExceptions thrown from the
0393: * callable statement will cause an event to be fired on the connection
0394: * pool listeners.
0395: *
0396: * @throws SQLException if an error occurs
0397: */
0398: public Object getObject(int parameterIndex, java.util.Map map)
0399: throws SQLException {
0400: validateConnection();
0401:
0402: try {
0403: return _callableStatement.getObject(parameterIndex, map);
0404: } catch (SQLException sqlException) {
0405: processSQLException(sqlException);
0406: }
0407:
0408: return null;
0409: }
0410:
0411: /**
0412: * Delgates calls to the callable statement; SQLExceptions thrown from the
0413: * callable statement will cause an event to be fired on the connection
0414: * pool listeners.
0415: *
0416: * @throws SQLException if an error occurs
0417: */
0418: public Ref getRef(int parameterIndex) throws SQLException {
0419: validateConnection();
0420:
0421: try {
0422: return _callableStatement.getRef(parameterIndex);
0423: } catch (SQLException sqlException) {
0424: processSQLException(sqlException);
0425: }
0426:
0427: return null;
0428: }
0429:
0430: /**
0431: * Delgates calls to the callable statement; SQLExceptions thrown from the
0432: * callable statement will cause an event to be fired on the connection
0433: * pool listeners.
0434: *
0435: * @throws SQLException if an error occurs
0436: */
0437: public Blob getBlob(int parameterIndex) throws SQLException {
0438: validateConnection();
0439:
0440: try {
0441: return _callableStatement.getBlob(parameterIndex);
0442: } catch (SQLException sqlException) {
0443: processSQLException(sqlException);
0444: }
0445:
0446: return null;
0447: }
0448:
0449: /**
0450: * Delgates calls to the callable statement; SQLExceptions thrown from the
0451: * callable statement will cause an event to be fired on the connection
0452: * pool listeners.
0453: *
0454: * @throws SQLException if an error occurs
0455: */
0456: public Clob getClob(int parameterIndex) throws SQLException {
0457: validateConnection();
0458:
0459: try {
0460: return _callableStatement.getClob(parameterIndex);
0461: } catch (SQLException sqlException) {
0462: processSQLException(sqlException);
0463: }
0464:
0465: return null;
0466: }
0467:
0468: /**
0469: * Delgates calls to the callable statement; SQLExceptions thrown from the
0470: * callable statement will cause an event to be fired on the connection
0471: * pool listeners.
0472: *
0473: * @throws SQLException if an error occurs
0474: */
0475: public Array getArray(int parameterIndex) throws SQLException {
0476: validateConnection();
0477:
0478: try {
0479: return _callableStatement.getArray(parameterIndex);
0480: } catch (SQLException sqlException) {
0481: processSQLException(sqlException);
0482: }
0483:
0484: return null;
0485: }
0486:
0487: /**
0488: * Delgates calls to the callable statement; SQLExceptions thrown from the
0489: * callable statement will cause an event to be fired on the connection
0490: * pool listeners.
0491: *
0492: * @throws SQLException if an error occurs
0493: */
0494: public Date getDate(int parameterIndex, Calendar cal)
0495: throws SQLException {
0496: validateConnection();
0497:
0498: try {
0499: return _callableStatement.getDate(parameterIndex, cal);
0500: } catch (SQLException sqlException) {
0501: processSQLException(sqlException);
0502: }
0503:
0504: return null;
0505: }
0506:
0507: /**
0508: * Delgates calls to the callable statement; SQLExceptions thrown from the
0509: * callable statement will cause an event to be fired on the connection
0510: * pool listeners.
0511: *
0512: * @throws SQLException if an error occurs
0513: */
0514: public Time getTime(int parameterIndex, Calendar cal)
0515: throws SQLException {
0516: validateConnection();
0517:
0518: try {
0519: return _callableStatement.getTime(parameterIndex, cal);
0520: } catch (SQLException sqlException) {
0521: processSQLException(sqlException);
0522: }
0523:
0524: return null;
0525: }
0526:
0527: /**
0528: * Delgates calls to the callable statement; SQLExceptions thrown from the
0529: * callable statement will cause an event to be fired on the connection
0530: * pool listeners.
0531: *
0532: * @throws SQLException if an error occurs
0533: */
0534: public Timestamp getTimestamp(int parameterIndex, Calendar cal)
0535: throws SQLException {
0536: validateConnection();
0537:
0538: try {
0539: return _callableStatement.getTimestamp(parameterIndex, cal);
0540: } catch (SQLException sqlException) {
0541: processSQLException(sqlException);
0542: }
0543:
0544: return null;
0545: }
0546:
0547: /**
0548: * Delgates calls to the callable statement; SQLExceptions thrown from the
0549: * callable statement will cause an event to be fired on the connection
0550: * pool listeners.
0551: *
0552: * @throws SQLException if an error occurs
0553: */
0554: public void registerOutParameter(int parameterIndex, int sqlType,
0555: String typeName) throws SQLException {
0556: validateConnection();
0557:
0558: try {
0559: _callableStatement.registerOutParameter(parameterIndex,
0560: sqlType, typeName);
0561: } catch (SQLException sqlException) {
0562: processSQLException(sqlException);
0563: }
0564: }
0565:
0566: /**
0567: * Delgates calls to the callable statement; SQLExceptions thrown from the
0568: * callable statement will cause an event to be fired on the connection
0569: * pool listeners.
0570: *
0571: * @throws SQLException if an error occurs
0572: */
0573: public void registerOutParameter(String parameterName, int sqlType)
0574: throws SQLException {
0575: validateConnection();
0576:
0577: try {
0578: _callableStatement.registerOutParameter(parameterName,
0579: sqlType);
0580: } catch (SQLException sqlException) {
0581: processSQLException(sqlException);
0582: }
0583: }
0584:
0585: /**
0586: * Delgates calls to the callable statement; SQLExceptions thrown from the
0587: * callable statement will cause an event to be fired on the connection
0588: * pool listeners.
0589: *
0590: * @throws SQLException if an error occurs
0591: */
0592: public void registerOutParameter(String parameterName, int sqlType,
0593: int scale) throws SQLException {
0594: validateConnection();
0595:
0596: try {
0597: _callableStatement.registerOutParameter(parameterName,
0598: sqlType, scale);
0599: } catch (SQLException sqlException) {
0600: processSQLException(sqlException);
0601: }
0602: }
0603:
0604: /**
0605: * Delgates calls to the callable statement; SQLExceptions thrown from the
0606: * callable statement will cause an event to be fired on the connection
0607: * pool listeners.
0608: *
0609: * @throws SQLException if an error occurs
0610: */
0611: public void registerOutParameter(String parameterName, int sqlType,
0612: String typeName) throws SQLException {
0613: validateConnection();
0614:
0615: try {
0616: _callableStatement.registerOutParameter(parameterName,
0617: sqlType, typeName);
0618: } catch (SQLException sqlException) {
0619: processSQLException(sqlException);
0620: }
0621: }
0622:
0623: /**
0624: * Delgates calls to the callable statement; SQLExceptions thrown from the
0625: * callable statement will cause an event to be fired on the connection
0626: * pool listeners.
0627: *
0628: * @throws SQLException if an error occurs
0629: */
0630: public java.net.URL getURL(int parameterIndex) throws SQLException {
0631: validateConnection();
0632:
0633: try {
0634: return _callableStatement.getURL(parameterIndex);
0635: } catch (SQLException sqlException) {
0636: processSQLException(sqlException);
0637: }
0638:
0639: return null;
0640: }
0641:
0642: /**
0643: * Delgates calls to the callable statement; SQLExceptions thrown from the
0644: * callable statement will cause an event to be fired on the connection
0645: * pool listeners.
0646: *
0647: * @throws SQLException if an error occurs
0648: */
0649: public void setURL(String parameterName, java.net.URL val)
0650: throws SQLException {
0651: validateConnection();
0652:
0653: try {
0654: _callableStatement.setURL(parameterName, val);
0655: } catch (SQLException sqlException) {
0656: processSQLException(sqlException);
0657: }
0658: }
0659:
0660: /**
0661: * Delgates calls to the callable statement; SQLExceptions thrown from the
0662: * callable statement will cause an event to be fired on the connection
0663: * pool listeners.
0664: *
0665: * @throws SQLException if an error occurs
0666: */
0667: public void setNull(String parameterName, int sqlType)
0668: throws SQLException {
0669: validateConnection();
0670:
0671: try {
0672: _callableStatement.setNull(parameterName, sqlType);
0673: } catch (SQLException sqlException) {
0674: processSQLException(sqlException);
0675: }
0676: }
0677:
0678: /**
0679: * Delgates calls to the callable statement; SQLExceptions thrown from the
0680: * callable statement will cause an event to be fired on the connection
0681: * pool listeners.
0682: *
0683: * @throws SQLException if an error occurs
0684: */
0685: public void setBoolean(String parameterName, boolean x)
0686: throws SQLException {
0687: validateConnection();
0688:
0689: try {
0690: _callableStatement.setBoolean(parameterName, x);
0691: } catch (SQLException sqlException) {
0692: processSQLException(sqlException);
0693: }
0694: }
0695:
0696: /**
0697: * Delgates calls to the callable statement; SQLExceptions thrown from the
0698: * callable statement will cause an event to be fired on the connection
0699: * pool listeners.
0700: *
0701: * @throws SQLException if an error occurs
0702: */
0703: public void setByte(String parameterName, byte x)
0704: throws SQLException {
0705: validateConnection();
0706:
0707: try {
0708: _callableStatement.setByte(parameterName, x);
0709: } catch (SQLException sqlException) {
0710: processSQLException(sqlException);
0711: }
0712: }
0713:
0714: /**
0715: * Delgates calls to the callable statement; SQLExceptions thrown from the
0716: * callable statement will cause an event to be fired on the connection
0717: * pool listeners.
0718: *
0719: * @throws SQLException if an error occurs
0720: */
0721: public void setShort(String parameterName, short x)
0722: throws SQLException {
0723: validateConnection();
0724:
0725: try {
0726: _callableStatement.setShort(parameterName, x);
0727: } catch (SQLException sqlException) {
0728: processSQLException(sqlException);
0729: }
0730: }
0731:
0732: /**
0733: * Delgates calls to the callable statement; SQLExceptions thrown from the
0734: * callable statement will cause an event to be fired on the connection
0735: * pool listeners.
0736: *
0737: * @throws SQLException if an error occurs
0738: */
0739: public void setInt(String parameterName, int x) throws SQLException {
0740: validateConnection();
0741:
0742: try {
0743: _callableStatement.setInt(parameterName, x);
0744: } catch (SQLException sqlException) {
0745: processSQLException(sqlException);
0746: }
0747: }
0748:
0749: /**
0750: * Delgates calls to the callable statement; SQLExceptions thrown from the
0751: * callable statement will cause an event to be fired on the connection
0752: * pool listeners.
0753: *
0754: * @throws SQLException if an error occurs
0755: */
0756: public void setLong(String parameterName, long x)
0757: throws SQLException {
0758: validateConnection();
0759:
0760: try {
0761: _callableStatement.setLong(parameterName, x);
0762: } catch (SQLException sqlException) {
0763: processSQLException(sqlException);
0764: }
0765: }
0766:
0767: /**
0768: * Delgates calls to the callable statement; SQLExceptions thrown from the
0769: * callable statement will cause an event to be fired on the connection
0770: * pool listeners.
0771: *
0772: * @throws SQLException if an error occurs
0773: */
0774: public void setFloat(String parameterName, float x)
0775: throws SQLException {
0776: validateConnection();
0777:
0778: try {
0779: _callableStatement.setFloat(parameterName, x);
0780: } catch (SQLException sqlException) {
0781: processSQLException(sqlException);
0782: }
0783: }
0784:
0785: /**
0786: * Delgates calls to the callable statement; SQLExceptions thrown from the
0787: * callable statement will cause an event to be fired on the connection
0788: * pool listeners.
0789: *
0790: * @throws SQLException if an error occurs
0791: */
0792: public void setDouble(String parameterName, double x)
0793: throws SQLException {
0794: validateConnection();
0795:
0796: try {
0797: _callableStatement.setDouble(parameterName, x);
0798: } catch (SQLException sqlException) {
0799: processSQLException(sqlException);
0800: }
0801: }
0802:
0803: /**
0804: * Delgates calls to the callable statement; SQLExceptions thrown from the
0805: * callable statement will cause an event to be fired on the connection
0806: * pool listeners.
0807: *
0808: * @throws SQLException if an error occurs
0809: */
0810: public void setBigDecimal(String parameterName, BigDecimal x)
0811: throws SQLException {
0812: validateConnection();
0813:
0814: try {
0815: _callableStatement.setBigDecimal(parameterName, x);
0816: } catch (SQLException sqlException) {
0817: processSQLException(sqlException);
0818: }
0819: }
0820:
0821: /**
0822: * Delgates calls to the callable statement; SQLExceptions thrown from the
0823: * callable statement will cause an event to be fired on the connection
0824: * pool listeners.
0825: *
0826: * @throws SQLException if an error occurs
0827: */
0828: public void setString(String parameterName, String x)
0829: throws SQLException {
0830: validateConnection();
0831:
0832: try {
0833: _callableStatement.setString(parameterName, x);
0834: } catch (SQLException sqlException) {
0835: processSQLException(sqlException);
0836: }
0837: }
0838:
0839: /**
0840: * Delgates calls to the callable statement; SQLExceptions thrown from the
0841: * callable statement will cause an event to be fired on the connection
0842: * pool listeners.
0843: *
0844: * @throws SQLException if an error occurs
0845: */
0846: public void setBytes(String parameterName, byte[] x)
0847: throws SQLException {
0848: validateConnection();
0849:
0850: try {
0851: _callableStatement.setBytes(parameterName, x);
0852: } catch (SQLException sqlException) {
0853: processSQLException(sqlException);
0854: }
0855: }
0856:
0857: /**
0858: * Delgates calls to the callable statement; SQLExceptions thrown from the
0859: * callable statement will cause an event to be fired on the connection
0860: * pool listeners.
0861: *
0862: * @throws SQLException if an error occurs
0863: */
0864: public void setDate(String parameterName, Date x)
0865: throws SQLException {
0866: validateConnection();
0867:
0868: try {
0869: _callableStatement.setDate(parameterName, x);
0870: } catch (SQLException sqlException) {
0871: processSQLException(sqlException);
0872: }
0873: }
0874:
0875: /**
0876: * Delgates calls to the callable statement; SQLExceptions thrown from the
0877: * callable statement will cause an event to be fired on the connection
0878: * pool listeners.
0879: *
0880: * @throws SQLException if an error occurs
0881: */
0882: public void setTime(String parameterName, Time x)
0883: throws SQLException {
0884: validateConnection();
0885:
0886: try {
0887: _callableStatement.setTime(parameterName, x);
0888: } catch (SQLException sqlException) {
0889: processSQLException(sqlException);
0890: }
0891: }
0892:
0893: /**
0894: * Delgates calls to the callable statement; SQLExceptions thrown from the
0895: * callable statement will cause an event to be fired on the connection
0896: * pool listeners.
0897: *
0898: * @throws SQLException if an error occurs
0899: */
0900: public void setTimestamp(String parameterName, Timestamp x)
0901: throws SQLException {
0902: validateConnection();
0903:
0904: try {
0905: _callableStatement.setTimestamp(parameterName, x);
0906: } catch (SQLException sqlException) {
0907: processSQLException(sqlException);
0908: }
0909: }
0910:
0911: /**
0912: * Delgates calls to the callable statement; SQLExceptions thrown from the
0913: * callable statement will cause an event to be fired on the connection
0914: * pool listeners.
0915: *
0916: * @throws SQLException if an error occurs
0917: */
0918: public void setAsciiStream(String parameterName,
0919: java.io.InputStream x, int length) throws SQLException {
0920: validateConnection();
0921:
0922: try {
0923: _callableStatement.setAsciiStream(parameterName, x, length);
0924: } catch (SQLException sqlException) {
0925: processSQLException(sqlException);
0926: }
0927: }
0928:
0929: /**
0930: * Delgates calls to the callable statement; SQLExceptions thrown from the
0931: * callable statement will cause an event to be fired on the connection
0932: * pool listeners.
0933: *
0934: * @throws SQLException if an error occurs
0935: */
0936: public void setBinaryStream(String parameterName,
0937: java.io.InputStream x, int length) throws SQLException {
0938: validateConnection();
0939:
0940: try {
0941: _callableStatement
0942: .setBinaryStream(parameterName, x, length);
0943: } catch (SQLException sqlException) {
0944: processSQLException(sqlException);
0945: }
0946: }
0947:
0948: /**
0949: * Delgates calls to the callable statement; SQLExceptions thrown from the
0950: * callable statement will cause an event to be fired on the connection
0951: * pool listeners.
0952: *
0953: * @throws SQLException if an error occurs
0954: */
0955: public void setObject(String parameterName, Object x,
0956: int targetSqlType, int scale) throws SQLException {
0957: validateConnection();
0958:
0959: try {
0960: _callableStatement.setObject(parameterName, x,
0961: targetSqlType, scale);
0962: } catch (SQLException sqlException) {
0963: processSQLException(sqlException);
0964: }
0965: }
0966:
0967: /**
0968: * Delgates calls to the callable statement; SQLExceptions thrown from the
0969: * callable statement will cause an event to be fired on the connection
0970: * pool listeners.
0971: *
0972: * @throws SQLException if an error occurs
0973: */
0974: public void setObject(String parameterName, Object x,
0975: int targetSqlType) throws SQLException {
0976: validateConnection();
0977:
0978: try {
0979: _callableStatement.setObject(parameterName, x,
0980: targetSqlType);
0981: } catch (SQLException sqlException) {
0982: processSQLException(sqlException);
0983: }
0984: }
0985:
0986: /**
0987: * Delgates calls to the callable statement; SQLExceptions thrown from the
0988: * callable statement will cause an event to be fired on the connection
0989: * pool listeners.
0990: *
0991: * @throws SQLException if an error occurs
0992: */
0993: public void setObject(String parameterName, Object x)
0994: throws SQLException {
0995: validateConnection();
0996:
0997: try {
0998: _callableStatement.setObject(parameterName, x);
0999: } catch (SQLException sqlException) {
1000: processSQLException(sqlException);
1001: }
1002: }
1003:
1004: /**
1005: * Delgates calls to the callable statement; SQLExceptions thrown from the
1006: * callable statement will cause an event to be fired on the connection
1007: * pool listeners.
1008: *
1009: * @throws SQLException if an error occurs
1010: */
1011: public void setCharacterStream(String parameterName,
1012: java.io.Reader x, int length) throws SQLException {
1013: validateConnection();
1014:
1015: try {
1016: _callableStatement.setCharacterStream(parameterName, x,
1017: length);
1018: } catch (SQLException sqlException) {
1019: processSQLException(sqlException);
1020: }
1021: }
1022:
1023: /**
1024: * Delgates calls to the callable statement; SQLExceptions thrown from the
1025: * callable statement will cause an event to be fired on the connection
1026: * pool listeners.
1027: *
1028: * @throws SQLException if an error occurs
1029: */
1030: public void setDate(String parameterName, Date x, Calendar cal)
1031: throws SQLException {
1032: validateConnection();
1033:
1034: try {
1035: _callableStatement.setDate(parameterName, x, cal);
1036: } catch (SQLException sqlException) {
1037: processSQLException(sqlException);
1038: }
1039: }
1040:
1041: /**
1042: * Delgates calls to the callable statement; SQLExceptions thrown from the
1043: * callable statement will cause an event to be fired on the connection
1044: * pool listeners.
1045: *
1046: * @throws SQLException if an error occurs
1047: */
1048: public void setTime(String parameterName, Time x, Calendar cal)
1049: throws SQLException {
1050: validateConnection();
1051:
1052: try {
1053: _callableStatement.setTime(parameterName, x, cal);
1054: } catch (SQLException sqlException) {
1055: processSQLException(sqlException);
1056: }
1057: }
1058:
1059: /**
1060: * Delgates calls to the callable statement; SQLExceptions thrown from the
1061: * callable statement will cause an event to be fired on the connection
1062: * pool listeners.
1063: *
1064: * @throws SQLException if an error occurs
1065: */
1066: public void setTimestamp(String parameterName, Timestamp x,
1067: Calendar cal) throws SQLException {
1068: validateConnection();
1069:
1070: try {
1071: _callableStatement.setTimestamp(parameterName, x, cal);
1072: } catch (SQLException sqlException) {
1073: processSQLException(sqlException);
1074: }
1075: }
1076:
1077: /**
1078: * Delgates calls to the callable statement; SQLExceptions thrown from the
1079: * callable statement will cause an event to be fired on the connection
1080: * pool listeners.
1081: *
1082: * @throws SQLException if an error occurs
1083: */
1084: public void setNull(String parameterName, int sqlType,
1085: String typeName) throws SQLException {
1086: validateConnection();
1087:
1088: try {
1089: _callableStatement
1090: .setNull(parameterName, sqlType, typeName);
1091: } catch (SQLException sqlException) {
1092: processSQLException(sqlException);
1093: }
1094: }
1095:
1096: /**
1097: * Delgates calls to the callable statement; SQLExceptions thrown from the
1098: * callable statement will cause an event to be fired on the connection
1099: * pool listeners.
1100: *
1101: * @throws SQLException if an error occurs
1102: */
1103: public String getString(String parameterName) throws SQLException {
1104: validateConnection();
1105:
1106: try {
1107: return _callableStatement.getString(parameterName);
1108: } catch (SQLException sqlException) {
1109: processSQLException(sqlException);
1110: }
1111:
1112: return null;
1113: }
1114:
1115: /**
1116: * Delgates calls to the callable statement; SQLExceptions thrown from the
1117: * callable statement will cause an event to be fired on the connection
1118: * pool listeners.
1119: *
1120: * @throws SQLException if an error occurs
1121: */
1122: public boolean getBoolean(String parameterName) throws SQLException {
1123: validateConnection();
1124:
1125: try {
1126: return _callableStatement.getBoolean(parameterName);
1127: } catch (SQLException sqlException) {
1128: processSQLException(sqlException);
1129: }
1130:
1131: return false;
1132: }
1133:
1134: /**
1135: * Delgates calls to the callable statement; SQLExceptions thrown from the
1136: * callable statement will cause an event to be fired on the connection
1137: * pool listeners.
1138: *
1139: * @throws SQLException if an error occurs
1140: */
1141: public byte getByte(String parameterName) throws SQLException {
1142: validateConnection();
1143:
1144: try {
1145: return _callableStatement.getByte(parameterName);
1146: } catch (SQLException sqlException) {
1147: processSQLException(sqlException);
1148: }
1149:
1150: return Byte.MIN_VALUE;
1151: }
1152:
1153: /**
1154: * Delgates calls to the callable statement; SQLExceptions thrown from the
1155: * callable statement will cause an event to be fired on the connection
1156: * pool listeners.
1157: *
1158: * @throws SQLException if an error occurs
1159: */
1160: public short getShort(String parameterName) throws SQLException {
1161: validateConnection();
1162:
1163: try {
1164: return _callableStatement.getShort(parameterName);
1165: } catch (SQLException sqlException) {
1166: processSQLException(sqlException);
1167: }
1168:
1169: return Short.MIN_VALUE;
1170: }
1171:
1172: /**
1173: * Delgates calls to the callable statement; SQLExceptions thrown from the
1174: * callable statement will cause an event to be fired on the connection
1175: * pool listeners.
1176: *
1177: * @throws SQLException if an error occurs
1178: */
1179: public int getInt(String parameterName) throws SQLException {
1180: validateConnection();
1181:
1182: try {
1183: return _callableStatement.getInt(parameterName);
1184: } catch (SQLException sqlException) {
1185: processSQLException(sqlException);
1186: }
1187:
1188: return Integer.MIN_VALUE;
1189: }
1190:
1191: /**
1192: * Delgates calls to the callable statement; SQLExceptions thrown from the
1193: * callable statement will cause an event to be fired on the connection
1194: * pool listeners.
1195: *
1196: * @throws SQLException if an error occurs
1197: */
1198: public long getLong(String parameterName) throws SQLException {
1199: validateConnection();
1200:
1201: try {
1202: return _callableStatement.getLong(parameterName);
1203: } catch (SQLException sqlException) {
1204: processSQLException(sqlException);
1205: }
1206:
1207: return Long.MIN_VALUE;
1208: }
1209:
1210: /**
1211: * Delgates calls to the callable statement; SQLExceptions thrown from the
1212: * callable statement will cause an event to be fired on the connection
1213: * pool listeners.
1214: *
1215: * @throws SQLException if an error occurs
1216: */
1217: public float getFloat(String parameterName) throws SQLException {
1218: validateConnection();
1219:
1220: try {
1221: return _callableStatement.getFloat(parameterName);
1222: } catch (SQLException sqlException) {
1223: processSQLException(sqlException);
1224: }
1225:
1226: return Float.MIN_VALUE;
1227: }
1228:
1229: /**
1230: * Delgates calls to the callable statement; SQLExceptions thrown from the
1231: * callable statement will cause an event to be fired on the connection
1232: * pool listeners.
1233: *
1234: * @throws SQLException if an error occurs
1235: */
1236: public double getDouble(String parameterName) throws SQLException {
1237: validateConnection();
1238:
1239: try {
1240: return _callableStatement.getDouble(parameterName);
1241: } catch (SQLException sqlException) {
1242: processSQLException(sqlException);
1243: }
1244:
1245: return Double.MIN_VALUE;
1246: }
1247:
1248: /**
1249: * Delgates calls to the callable statement; SQLExceptions thrown from the
1250: * callable statement will cause an event to be fired on the connection
1251: * pool listeners.
1252: *
1253: * @throws SQLException if an error occurs
1254: */
1255: public byte[] getBytes(String parameterName) throws SQLException {
1256: validateConnection();
1257:
1258: try {
1259: return _callableStatement.getBytes(parameterName);
1260: } catch (SQLException sqlException) {
1261: processSQLException(sqlException);
1262: }
1263:
1264: return null;
1265: }
1266:
1267: /**
1268: * Delgates calls to the callable statement; SQLExceptions thrown from the
1269: * callable statement will cause an event to be fired on the connection
1270: * pool listeners.
1271: *
1272: * @throws SQLException if an error occurs
1273: */
1274: public Date getDate(String parameterName) throws SQLException {
1275: validateConnection();
1276:
1277: try {
1278: return _callableStatement.getDate(parameterName);
1279: } catch (SQLException sqlException) {
1280: processSQLException(sqlException);
1281: }
1282:
1283: return null;
1284: }
1285:
1286: /**
1287: * Delgates calls to the callable statement; SQLExceptions thrown from the
1288: * callable statement will cause an event to be fired on the connection
1289: * pool listeners.
1290: *
1291: * @throws SQLException if an error occurs
1292: */
1293: public Time getTime(String parameterName) throws SQLException {
1294: validateConnection();
1295:
1296: try {
1297: return _callableStatement.getTime(parameterName);
1298: } catch (SQLException sqlException) {
1299: processSQLException(sqlException);
1300: }
1301:
1302: return null;
1303: }
1304:
1305: /**
1306: * Delgates calls to the callable statement; SQLExceptions thrown from the
1307: * callable statement will cause an event to be fired on the connection
1308: * pool listeners.
1309: *
1310: * @throws SQLException if an error occurs
1311: */
1312: public Timestamp getTimestamp(String parameterName)
1313: throws SQLException {
1314: validateConnection();
1315:
1316: try {
1317: return _callableStatement.getTimestamp(parameterName);
1318: } catch (SQLException sqlException) {
1319: processSQLException(sqlException);
1320: }
1321:
1322: return null;
1323: }
1324:
1325: /**
1326: * Delgates calls to the callable statement; SQLExceptions thrown from the
1327: * callable statement will cause an event to be fired on the connection
1328: * pool listeners.
1329: *
1330: * @throws SQLException if an error occurs
1331: */
1332: public Object getObject(String parameterName) throws SQLException {
1333: validateConnection();
1334:
1335: try {
1336: return _callableStatement.getObject(parameterName);
1337: } catch (SQLException sqlException) {
1338: processSQLException(sqlException);
1339: }
1340:
1341: return null;
1342: }
1343:
1344: /**
1345: * Delgates calls to the callable statement; SQLExceptions thrown from the
1346: * callable statement will cause an event to be fired on the connection
1347: * pool listeners.
1348: *
1349: * @throws SQLException if an error occurs
1350: */
1351: public BigDecimal getBigDecimal(String parameterName)
1352: throws SQLException {
1353: validateConnection();
1354:
1355: try {
1356: return _callableStatement.getBigDecimal(parameterName);
1357: } catch (SQLException sqlException) {
1358: processSQLException(sqlException);
1359: }
1360:
1361: return null;
1362: }
1363:
1364: /**
1365: * Delgates calls to the callable statement; SQLExceptions thrown from the
1366: * callable statement will cause an event to be fired on the connection
1367: * pool listeners.
1368: *
1369: * @throws SQLException if an error occurs
1370: */
1371: public Object getObject(String parameterName, java.util.Map map)
1372: throws SQLException {
1373: validateConnection();
1374:
1375: try {
1376: return _callableStatement.getObject(parameterName, map);
1377: } catch (SQLException sqlException) {
1378: processSQLException(sqlException);
1379: }
1380:
1381: return null;
1382: }
1383:
1384: /**
1385: * Delgates calls to the callable statement; SQLExceptions thrown from the
1386: * callable statement will cause an event to be fired on the connection
1387: * pool listeners.
1388: *
1389: * @throws SQLException if an error occurs
1390: */
1391: public Ref getRef(String parameterName) throws SQLException {
1392: validateConnection();
1393:
1394: try {
1395: return _callableStatement.getRef(parameterName);
1396: } catch (SQLException sqlException) {
1397: processSQLException(sqlException);
1398: }
1399:
1400: return null;
1401: }
1402:
1403: /**
1404: * Delgates calls to the callable statement; SQLExceptions thrown from the
1405: * callable statement will cause an event to be fired on the connection
1406: * pool listeners.
1407: *
1408: * @throws SQLException if an error occurs
1409: */
1410: public Blob getBlob(String parameterName) throws SQLException {
1411: validateConnection();
1412:
1413: try {
1414: return _callableStatement.getBlob(parameterName);
1415: } catch (SQLException sqlException) {
1416: processSQLException(sqlException);
1417: }
1418:
1419: return null;
1420: }
1421:
1422: /**
1423: * Delgates calls to the callable statement; SQLExceptions thrown from the
1424: * callable statement will cause an event to be fired on the connection
1425: * pool listeners.
1426: *
1427: * @throws SQLException if an error occurs
1428: */
1429: public Clob getClob(String parameterName) throws SQLException {
1430: validateConnection();
1431:
1432: try {
1433: return _callableStatement.getClob(parameterName);
1434: } catch (SQLException sqlException) {
1435: processSQLException(sqlException);
1436: }
1437:
1438: return null;
1439: }
1440:
1441: /**
1442: * Delgates calls to the callable statement; SQLExceptions thrown from the
1443: * callable statement will cause an event to be fired on the connection
1444: * pool listeners.
1445: *
1446: * @throws SQLException if an error occurs
1447: */
1448: public Array getArray(String parameterName) throws SQLException {
1449: validateConnection();
1450:
1451: try {
1452: return _callableStatement.getArray(parameterName);
1453: } catch (SQLException sqlException) {
1454: processSQLException(sqlException);
1455: }
1456:
1457: return null;
1458: }
1459:
1460: /**
1461: * Delgates calls to the callable statement; SQLExceptions thrown from the
1462: * callable statement will cause an event to be fired on the connection
1463: * pool listeners.
1464: *
1465: * @throws SQLException if an error occurs
1466: */
1467: public Date getDate(String parameterName, Calendar cal)
1468: throws SQLException {
1469: validateConnection();
1470:
1471: try {
1472: return _callableStatement.getDate(parameterName, cal);
1473: } catch (SQLException sqlException) {
1474: processSQLException(sqlException);
1475: }
1476:
1477: return null;
1478: }
1479:
1480: /**
1481: * Delgates calls to the callable statement; SQLExceptions thrown from the
1482: * callable statement will cause an event to be fired on the connection
1483: * pool listeners.
1484: *
1485: * @throws SQLException if an error occurs
1486: */
1487: public Time getTime(String parameterName, Calendar cal)
1488: throws SQLException {
1489: validateConnection();
1490:
1491: try {
1492: return _callableStatement.getTime(parameterName, cal);
1493: } catch (SQLException sqlException) {
1494: processSQLException(sqlException);
1495: }
1496:
1497: return null;
1498: }
1499:
1500: /**
1501: * Delgates calls to the callable statement; SQLExceptions thrown from the
1502: * callable statement will cause an event to be fired on the connection
1503: * pool listeners.
1504: *
1505: * @throws SQLException if an error occurs
1506: */
1507: public Timestamp getTimestamp(String parameterName, Calendar cal)
1508: throws SQLException {
1509: validateConnection();
1510:
1511: try {
1512: return _callableStatement.getTimestamp(parameterName, cal);
1513: } catch (SQLException sqlException) {
1514: processSQLException(sqlException);
1515: }
1516:
1517: return null;
1518: }
1519:
1520: /**
1521: * Delgates calls to the callable statement; SQLExceptions thrown from the
1522: * callable statement will cause an event to be fired on the connection
1523: * pool listeners.
1524: *
1525: * @throws SQLException if an error occurs
1526: */
1527: public java.net.URL getURL(String parameterName)
1528: throws SQLException {
1529: validateConnection();
1530:
1531: try {
1532: return _callableStatement.getURL(parameterName);
1533: } catch (SQLException sqlException) {
1534: processSQLException(sqlException);
1535: }
1536:
1537: return null;
1538: }
1539: }
|