0001: /*
0002: Copyright (C) 2002-2007 MySQL AB
0003:
0004: This program is free software; you can redistribute it and/or modify
0005: it under the terms of version 2 of the GNU General Public License as
0006: published by the Free Software Foundation.
0007:
0008: There are special exceptions to the terms and conditions of the GPL
0009: as it is applied to this software. View the full text of the
0010: exception in file EXCEPTIONS-CONNECTOR-J in the directory of this
0011: software distribution.
0012:
0013: This program is distributed in the hope that it will be useful,
0014: but WITHOUT ANY WARRANTY; without even the implied warranty of
0015: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
0016: GNU General Public License for more details.
0017:
0018: You should have received a copy of the GNU General Public License
0019: along with this program; if not, write to the Free Software
0020: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0021:
0022:
0023: */
0024:
0025: package com.mysql.jdbc.jdbc2.optional;
0026:
0027: import java.io.InputStream;
0028: import java.io.Reader;
0029: import java.math.BigDecimal;
0030: import java.net.URL;
0031: import java.sql.Array;
0032: import java.sql.Blob;
0033: import java.sql.CallableStatement;
0034: import java.sql.Clob;
0035: import java.sql.Date; //import java.sql.NClob;
0036: import java.sql.Ref; //import java.sql.RowId;
0037: import java.sql.SQLException; //import java.sql.SQLXML;
0038: import java.sql.Time;
0039: import java.sql.Timestamp;
0040: import java.util.Calendar;
0041: import java.util.Map;
0042:
0043: import com.mysql.jdbc.SQLError;
0044: import com.mysql.jdbc.exceptions.NotYetImplementedException;
0045:
0046: /**
0047: * Wraps callable statements created by pooled connections.
0048: *
0049: * @version $Id: CallableStatementWrapper.java,v 1.1.2.1 2005/05/13 18:58:38
0050: * mmatthews Exp $
0051: */
0052: public class CallableStatementWrapper extends PreparedStatementWrapper
0053: implements CallableStatement {
0054:
0055: /**
0056: * @param c
0057: * @param conn
0058: * @param toWrap
0059: */
0060: public CallableStatementWrapper(ConnectionWrapper c,
0061: MysqlPooledConnection conn, CallableStatement toWrap) {
0062: super (c, conn, toWrap);
0063: }
0064:
0065: /*
0066: * (non-Javadoc)
0067: *
0068: * @see java.sql.CallableStatement#registerOutParameter(int, int)
0069: */
0070: public void registerOutParameter(int parameterIndex, int sqlType)
0071: throws SQLException {
0072: try {
0073: if (this .wrappedStmt != null) {
0074: ((CallableStatement) this .wrappedStmt)
0075: .registerOutParameter(parameterIndex, sqlType);
0076: } else {
0077: throw SQLError.createSQLException(
0078: "No operations allowed after statement closed",
0079: SQLError.SQL_STATE_GENERAL_ERROR);
0080: }
0081: } catch (SQLException sqlEx) {
0082: checkAndFireConnectionError(sqlEx);
0083: }
0084: }
0085:
0086: /*
0087: * (non-Javadoc)
0088: *
0089: * @see java.sql.CallableStatement#registerOutParameter(int, int, int)
0090: */
0091: public void registerOutParameter(int parameterIndex, int sqlType,
0092: int scale) throws SQLException {
0093: try {
0094: if (this .wrappedStmt != null) {
0095: ((CallableStatement) this .wrappedStmt)
0096: .registerOutParameter(parameterIndex, sqlType,
0097: scale);
0098: } else {
0099: throw SQLError.createSQLException(
0100: "No operations allowed after statement closed",
0101: SQLError.SQL_STATE_GENERAL_ERROR);
0102: }
0103: } catch (SQLException sqlEx) {
0104: checkAndFireConnectionError(sqlEx);
0105: }
0106: }
0107:
0108: /*
0109: * (non-Javadoc)
0110: *
0111: * @see java.sql.CallableStatement#wasNull()
0112: */
0113: public boolean wasNull() throws SQLException {
0114: try {
0115: if (this .wrappedStmt != null) {
0116: return ((CallableStatement) this .wrappedStmt).wasNull();
0117: } else {
0118: throw SQLError.createSQLException(
0119: "No operations allowed after statement closed",
0120: SQLError.SQL_STATE_GENERAL_ERROR);
0121: }
0122: } catch (SQLException sqlEx) {
0123: checkAndFireConnectionError(sqlEx);
0124: }
0125:
0126: return false;
0127: }
0128:
0129: /*
0130: * (non-Javadoc)
0131: *
0132: * @see java.sql.CallableStatement#getString(int)
0133: */
0134: public String getString(int parameterIndex) throws SQLException {
0135: try {
0136: if (this .wrappedStmt != null) {
0137: return ((CallableStatement) this .wrappedStmt)
0138: .getString(parameterIndex);
0139: } else {
0140: throw SQLError.createSQLException(
0141: "No operations allowed after statement closed",
0142: SQLError.SQL_STATE_GENERAL_ERROR);
0143: }
0144: } catch (SQLException sqlEx) {
0145: checkAndFireConnectionError(sqlEx);
0146: }
0147: return null;
0148: }
0149:
0150: /*
0151: * (non-Javadoc)
0152: *
0153: * @see java.sql.CallableStatement#getBoolean(int)
0154: */
0155: public boolean getBoolean(int parameterIndex) throws SQLException {
0156: try {
0157: if (this .wrappedStmt != null) {
0158: return ((CallableStatement) this .wrappedStmt)
0159: .getBoolean(parameterIndex);
0160: } else {
0161: throw SQLError.createSQLException(
0162: "No operations allowed after statement closed",
0163: SQLError.SQL_STATE_GENERAL_ERROR);
0164: }
0165: } catch (SQLException sqlEx) {
0166: checkAndFireConnectionError(sqlEx);
0167: }
0168:
0169: return false;
0170: }
0171:
0172: /*
0173: * (non-Javadoc)
0174: *
0175: * @see java.sql.CallableStatement#getByte(int)
0176: */
0177: public byte getByte(int parameterIndex) throws SQLException {
0178: try {
0179: if (this .wrappedStmt != null) {
0180: return ((CallableStatement) this .wrappedStmt)
0181: .getByte(parameterIndex);
0182: } else {
0183: throw SQLError.createSQLException(
0184: "No operations allowed after statement closed",
0185: SQLError.SQL_STATE_GENERAL_ERROR);
0186: }
0187: } catch (SQLException sqlEx) {
0188: checkAndFireConnectionError(sqlEx);
0189: }
0190:
0191: return 0;
0192: }
0193:
0194: /*
0195: * (non-Javadoc)
0196: *
0197: * @see java.sql.CallableStatement#getShort(int)
0198: */
0199: public short getShort(int parameterIndex) throws SQLException {
0200: try {
0201: if (this .wrappedStmt != null) {
0202: return ((CallableStatement) this .wrappedStmt)
0203: .getShort(parameterIndex);
0204: } else {
0205: throw SQLError.createSQLException(
0206: "No operations allowed after statement closed",
0207: SQLError.SQL_STATE_GENERAL_ERROR);
0208: }
0209: } catch (SQLException sqlEx) {
0210: checkAndFireConnectionError(sqlEx);
0211: }
0212:
0213: return 0;
0214: }
0215:
0216: /*
0217: * (non-Javadoc)
0218: *
0219: * @see java.sql.CallableStatement#getInt(int)
0220: */
0221: public int getInt(int parameterIndex) throws SQLException {
0222: try {
0223: if (this .wrappedStmt != null) {
0224: return ((CallableStatement) this .wrappedStmt)
0225: .getInt(parameterIndex);
0226: } else {
0227: throw SQLError.createSQLException(
0228: "No operations allowed after statement closed",
0229: SQLError.SQL_STATE_GENERAL_ERROR);
0230: }
0231: } catch (SQLException sqlEx) {
0232: checkAndFireConnectionError(sqlEx);
0233: }
0234:
0235: return 0;
0236: }
0237:
0238: /*
0239: * (non-Javadoc)
0240: *
0241: * @see java.sql.CallableStatement#getLong(int)
0242: */
0243: public long getLong(int parameterIndex) throws SQLException {
0244: try {
0245: if (this .wrappedStmt != null) {
0246: return ((CallableStatement) this .wrappedStmt)
0247: .getLong(parameterIndex);
0248: } else {
0249: throw SQLError.createSQLException(
0250: "No operations allowed after statement closed",
0251: SQLError.SQL_STATE_GENERAL_ERROR);
0252: }
0253: } catch (SQLException sqlEx) {
0254: checkAndFireConnectionError(sqlEx);
0255: }
0256:
0257: return 0;
0258: }
0259:
0260: /*
0261: * (non-Javadoc)
0262: *
0263: * @see java.sql.CallableStatement#getFloat(int)
0264: */
0265: public float getFloat(int parameterIndex) throws SQLException {
0266: try {
0267: if (this .wrappedStmt != null) {
0268: return ((CallableStatement) this .wrappedStmt)
0269: .getFloat(parameterIndex);
0270: } else {
0271: throw SQLError.createSQLException(
0272: "No operations allowed after statement closed",
0273: SQLError.SQL_STATE_GENERAL_ERROR);
0274: }
0275: } catch (SQLException sqlEx) {
0276: checkAndFireConnectionError(sqlEx);
0277: }
0278:
0279: return 0;
0280: }
0281:
0282: /*
0283: * (non-Javadoc)
0284: *
0285: * @see java.sql.CallableStatement#getDouble(int)
0286: */
0287: public double getDouble(int parameterIndex) throws SQLException {
0288: try {
0289: if (this .wrappedStmt != null) {
0290: return ((CallableStatement) this .wrappedStmt)
0291: .getDouble(parameterIndex);
0292: } else {
0293: throw SQLError.createSQLException(
0294: "No operations allowed after statement closed",
0295: SQLError.SQL_STATE_GENERAL_ERROR);
0296: }
0297: } catch (SQLException sqlEx) {
0298: checkAndFireConnectionError(sqlEx);
0299: }
0300:
0301: return 0;
0302: }
0303:
0304: /*
0305: * (non-Javadoc)
0306: *
0307: * @see java.sql.CallableStatement#getBigDecimal(int, int)
0308: */
0309: public BigDecimal getBigDecimal(int parameterIndex, int scale)
0310: throws SQLException {
0311: try {
0312: if (this .wrappedStmt != null) {
0313: return ((CallableStatement) this .wrappedStmt)
0314: .getBigDecimal(parameterIndex, scale);
0315: } else {
0316: throw SQLError.createSQLException(
0317: "No operations allowed after statement closed",
0318: SQLError.SQL_STATE_GENERAL_ERROR);
0319: }
0320: } catch (SQLException sqlEx) {
0321: checkAndFireConnectionError(sqlEx);
0322: }
0323:
0324: return null;
0325: }
0326:
0327: /*
0328: * (non-Javadoc)
0329: *
0330: * @see java.sql.CallableStatement#getBytes(int)
0331: */
0332: public byte[] getBytes(int parameterIndex) throws SQLException {
0333: try {
0334: if (this .wrappedStmt != null) {
0335: return ((CallableStatement) this .wrappedStmt)
0336: .getBytes(parameterIndex);
0337: } else {
0338: throw SQLError.createSQLException(
0339: "No operations allowed after statement closed",
0340: SQLError.SQL_STATE_GENERAL_ERROR);
0341: }
0342: } catch (SQLException sqlEx) {
0343: checkAndFireConnectionError(sqlEx);
0344: }
0345:
0346: return null;
0347: }
0348:
0349: /*
0350: * (non-Javadoc)
0351: *
0352: * @see java.sql.CallableStatement#getDate(int)
0353: */
0354: public Date getDate(int parameterIndex) throws SQLException {
0355: try {
0356: if (this .wrappedStmt != null) {
0357: return ((CallableStatement) this .wrappedStmt)
0358: .getDate(parameterIndex);
0359: } else {
0360: throw SQLError.createSQLException(
0361: "No operations allowed after statement closed",
0362: SQLError.SQL_STATE_GENERAL_ERROR);
0363: }
0364: } catch (SQLException sqlEx) {
0365: checkAndFireConnectionError(sqlEx);
0366: }
0367:
0368: return null;
0369: }
0370:
0371: /*
0372: * (non-Javadoc)
0373: *
0374: * @see java.sql.CallableStatement#getTime(int)
0375: */
0376: public Time getTime(int parameterIndex) throws SQLException {
0377: try {
0378: if (this .wrappedStmt != null) {
0379: return ((CallableStatement) this .wrappedStmt)
0380: .getTime(parameterIndex);
0381: } else {
0382: throw SQLError.createSQLException(
0383: "No operations allowed after statement closed",
0384: SQLError.SQL_STATE_GENERAL_ERROR);
0385: }
0386: } catch (SQLException sqlEx) {
0387: checkAndFireConnectionError(sqlEx);
0388: }
0389:
0390: return null;
0391: }
0392:
0393: /*
0394: * (non-Javadoc)
0395: *
0396: * @see java.sql.CallableStatement#getTimestamp(int)
0397: */
0398: public Timestamp getTimestamp(int parameterIndex)
0399: throws SQLException {
0400: try {
0401: if (this .wrappedStmt != null) {
0402: return ((CallableStatement) this .wrappedStmt)
0403: .getTimestamp(parameterIndex);
0404: } else {
0405: throw SQLError.createSQLException(
0406: "No operations allowed after statement closed",
0407: SQLError.SQL_STATE_GENERAL_ERROR);
0408: }
0409: } catch (SQLException sqlEx) {
0410: checkAndFireConnectionError(sqlEx);
0411: }
0412:
0413: return null;
0414: }
0415:
0416: /*
0417: * (non-Javadoc)
0418: *
0419: * @see java.sql.CallableStatement#getObject(int)
0420: */
0421: public Object getObject(int parameterIndex) throws SQLException {
0422: try {
0423: if (this .wrappedStmt != null) {
0424: return ((CallableStatement) this .wrappedStmt)
0425: .getObject(parameterIndex);
0426: } else {
0427: throw SQLError.createSQLException(
0428: "No operations allowed after statement closed",
0429: SQLError.SQL_STATE_GENERAL_ERROR);
0430: }
0431: } catch (SQLException sqlEx) {
0432: checkAndFireConnectionError(sqlEx);
0433: }
0434:
0435: return null;
0436: }
0437:
0438: /*
0439: * (non-Javadoc)
0440: *
0441: * @see java.sql.CallableStatement#getBigDecimal(int)
0442: */
0443: public BigDecimal getBigDecimal(int parameterIndex)
0444: throws SQLException {
0445: try {
0446: if (this .wrappedStmt != null) {
0447: return ((CallableStatement) this .wrappedStmt)
0448: .getBigDecimal(parameterIndex);
0449: } else {
0450: throw SQLError.createSQLException(
0451: "No operations allowed after statement closed",
0452: SQLError.SQL_STATE_GENERAL_ERROR);
0453: }
0454: } catch (SQLException sqlEx) {
0455: checkAndFireConnectionError(sqlEx);
0456: }
0457:
0458: return null;
0459: }
0460:
0461: /*
0462: * (non-Javadoc)
0463: *
0464: * @see java.sql.CallableStatement#getObject(int, java.util.Map)
0465: */
0466: public Object getObject(int parameterIndex, Map typeMap)
0467: throws SQLException {
0468: try {
0469: if (this .wrappedStmt != null) {
0470: return ((CallableStatement) this .wrappedStmt)
0471: .getObject(parameterIndex, typeMap);
0472: } else {
0473: throw SQLError.createSQLException(
0474: "No operations allowed after statement closed",
0475: SQLError.SQL_STATE_GENERAL_ERROR);
0476: }
0477: } catch (SQLException sqlEx) {
0478: checkAndFireConnectionError(sqlEx);
0479: }
0480: return null;
0481: }
0482:
0483: /*
0484: * (non-Javadoc)
0485: *
0486: * @see java.sql.CallableStatement#getRef(int)
0487: */
0488: public Ref getRef(int parameterIndex) throws SQLException {
0489: try {
0490: if (this .wrappedStmt != null) {
0491: return ((CallableStatement) this .wrappedStmt)
0492: .getRef(parameterIndex);
0493: } else {
0494: throw SQLError.createSQLException(
0495: "No operations allowed after statement closed",
0496: SQLError.SQL_STATE_GENERAL_ERROR);
0497: }
0498: } catch (SQLException sqlEx) {
0499: checkAndFireConnectionError(sqlEx);
0500: }
0501:
0502: return null;
0503: }
0504:
0505: /*
0506: * (non-Javadoc)
0507: *
0508: * @see java.sql.CallableStatement#getBlob(int)
0509: */
0510: public Blob getBlob(int parameterIndex) throws SQLException {
0511: try {
0512: if (this .wrappedStmt != null) {
0513: return ((CallableStatement) this .wrappedStmt)
0514: .getBlob(parameterIndex);
0515: } else {
0516: throw SQLError.createSQLException(
0517: "No operations allowed after statement closed",
0518: SQLError.SQL_STATE_GENERAL_ERROR);
0519: }
0520: } catch (SQLException sqlEx) {
0521: checkAndFireConnectionError(sqlEx);
0522: }
0523:
0524: return null;
0525: }
0526:
0527: /*
0528: * (non-Javadoc)
0529: *
0530: * @see java.sql.CallableStatement#getClob(int)
0531: */
0532: public Clob getClob(int parameterIndex) throws SQLException {
0533: try {
0534: if (this .wrappedStmt != null) {
0535: return ((CallableStatement) this .wrappedStmt)
0536: .getClob(parameterIndex);
0537: } else {
0538: throw SQLError.createSQLException(
0539: "No operations allowed after statement closed",
0540: SQLError.SQL_STATE_GENERAL_ERROR);
0541: }
0542: } catch (SQLException sqlEx) {
0543: checkAndFireConnectionError(sqlEx);
0544: }
0545: return null;
0546: }
0547:
0548: /*
0549: * (non-Javadoc)
0550: *
0551: * @see java.sql.CallableStatement#getArray(int)
0552: */
0553: public Array getArray(int parameterIndex) throws SQLException {
0554: try {
0555: if (this .wrappedStmt != null) {
0556: return ((CallableStatement) this .wrappedStmt)
0557: .getArray(parameterIndex);
0558: } else {
0559: throw SQLError.createSQLException(
0560: "No operations allowed after statement closed",
0561: SQLError.SQL_STATE_GENERAL_ERROR);
0562: }
0563: } catch (SQLException sqlEx) {
0564: checkAndFireConnectionError(sqlEx);
0565: }
0566: return null;
0567: }
0568:
0569: /*
0570: * (non-Javadoc)
0571: *
0572: * @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
0573: */
0574: public Date getDate(int parameterIndex, Calendar cal)
0575: throws SQLException {
0576: try {
0577: if (this .wrappedStmt != null) {
0578: return ((CallableStatement) this .wrappedStmt).getDate(
0579: parameterIndex, cal);
0580: } else {
0581: throw SQLError.createSQLException(
0582: "No operations allowed after statement closed",
0583: SQLError.SQL_STATE_GENERAL_ERROR);
0584: }
0585: } catch (SQLException sqlEx) {
0586: checkAndFireConnectionError(sqlEx);
0587: }
0588: return null;
0589: }
0590:
0591: /*
0592: * (non-Javadoc)
0593: *
0594: * @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
0595: */
0596: public Time getTime(int parameterIndex, Calendar cal)
0597: throws SQLException {
0598: try {
0599: if (this .wrappedStmt != null) {
0600: return ((CallableStatement) this .wrappedStmt).getTime(
0601: parameterIndex, cal);
0602: } else {
0603: throw SQLError.createSQLException(
0604: "No operations allowed after statement closed",
0605: SQLError.SQL_STATE_GENERAL_ERROR);
0606: }
0607: } catch (SQLException sqlEx) {
0608: checkAndFireConnectionError(sqlEx);
0609: }
0610: return null;
0611: }
0612:
0613: /*
0614: * (non-Javadoc)
0615: *
0616: * @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
0617: */
0618: public Timestamp getTimestamp(int parameterIndex, Calendar cal)
0619: throws SQLException {
0620: try {
0621: if (this .wrappedStmt != null) {
0622: return ((CallableStatement) this .wrappedStmt)
0623: .getTimestamp(parameterIndex, cal);
0624: } else {
0625: throw SQLError.createSQLException(
0626: "No operations allowed after statement closed",
0627: SQLError.SQL_STATE_GENERAL_ERROR);
0628: }
0629: } catch (SQLException sqlEx) {
0630: checkAndFireConnectionError(sqlEx);
0631: }
0632: return null;
0633: }
0634:
0635: /*
0636: * (non-Javadoc)
0637: *
0638: * @see java.sql.CallableStatement#registerOutParameter(int, int,
0639: * java.lang.String)
0640: */
0641: public void registerOutParameter(int paramIndex, int sqlType,
0642: String typeName) throws SQLException {
0643: try {
0644: if (this .wrappedStmt != null) {
0645: ((CallableStatement) this .wrappedStmt)
0646: .registerOutParameter(paramIndex, sqlType,
0647: typeName);
0648: } else {
0649: throw SQLError.createSQLException(
0650: "No operations allowed after statement closed",
0651: SQLError.SQL_STATE_GENERAL_ERROR);
0652: }
0653: } catch (SQLException sqlEx) {
0654: checkAndFireConnectionError(sqlEx);
0655: }
0656: }
0657:
0658: /*
0659: * (non-Javadoc)
0660: *
0661: * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
0662: * int)
0663: */
0664: public void registerOutParameter(String parameterName, int sqlType)
0665: throws SQLException {
0666: try {
0667: if (this .wrappedStmt != null) {
0668: ((CallableStatement) this .wrappedStmt)
0669: .registerOutParameter(parameterName, sqlType);
0670: } else {
0671: throw SQLError.createSQLException(
0672: "No operations allowed after statement closed",
0673: SQLError.SQL_STATE_GENERAL_ERROR);
0674: }
0675: } catch (SQLException sqlEx) {
0676: checkAndFireConnectionError(sqlEx);
0677: }
0678: }
0679:
0680: /*
0681: * (non-Javadoc)
0682: *
0683: * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
0684: * int, int)
0685: */
0686: public void registerOutParameter(String parameterName, int sqlType,
0687: int scale) throws SQLException {
0688: try {
0689: if (this .wrappedStmt != null) {
0690: ((CallableStatement) this .wrappedStmt)
0691: .registerOutParameter(parameterName, sqlType,
0692: scale);
0693: } else {
0694: throw SQLError.createSQLException(
0695: "No operations allowed after statement closed",
0696: SQLError.SQL_STATE_GENERAL_ERROR);
0697: }
0698: } catch (SQLException sqlEx) {
0699: checkAndFireConnectionError(sqlEx);
0700: }
0701: }
0702:
0703: /*
0704: * (non-Javadoc)
0705: *
0706: * @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
0707: * int, java.lang.String)
0708: */
0709: public void registerOutParameter(String parameterName, int sqlType,
0710: String typeName) throws SQLException {
0711: try {
0712: if (this .wrappedStmt != null) {
0713: ((CallableStatement) this .wrappedStmt)
0714: .registerOutParameter(parameterName, sqlType,
0715: typeName);
0716: } else {
0717: throw SQLError.createSQLException(
0718: "No operations allowed after statement closed",
0719: SQLError.SQL_STATE_GENERAL_ERROR);
0720: }
0721: } catch (SQLException sqlEx) {
0722: checkAndFireConnectionError(sqlEx);
0723: }
0724: }
0725:
0726: /*
0727: * (non-Javadoc)
0728: *
0729: * @see java.sql.CallableStatement#getURL(int)
0730: */
0731: public URL getURL(int parameterIndex) throws SQLException {
0732: try {
0733: if (this .wrappedStmt != null) {
0734: return ((CallableStatement) this .wrappedStmt)
0735: .getURL(parameterIndex);
0736: } else {
0737: throw SQLError.createSQLException(
0738: "No operations allowed after statement closed",
0739: SQLError.SQL_STATE_GENERAL_ERROR);
0740: }
0741: } catch (SQLException sqlEx) {
0742: checkAndFireConnectionError(sqlEx);
0743: }
0744:
0745: return null;
0746: }
0747:
0748: /*
0749: * (non-Javadoc)
0750: *
0751: * @see java.sql.CallableStatement#setURL(java.lang.String, java.net.URL)
0752: */
0753: public void setURL(String parameterName, URL val)
0754: throws SQLException {
0755: try {
0756: if (this .wrappedStmt != null) {
0757: ((CallableStatement) this .wrappedStmt).setURL(
0758: parameterName, val);
0759: } else {
0760: throw SQLError.createSQLException(
0761: "No operations allowed after statement closed",
0762: SQLError.SQL_STATE_GENERAL_ERROR);
0763: }
0764: } catch (SQLException sqlEx) {
0765: checkAndFireConnectionError(sqlEx);
0766: }
0767: }
0768:
0769: /*
0770: * (non-Javadoc)
0771: *
0772: * @see java.sql.CallableStatement#setNull(java.lang.String, int)
0773: */
0774: public void setNull(String parameterName, int sqlType)
0775: throws SQLException {
0776: try {
0777: if (this .wrappedStmt != null) {
0778: ((CallableStatement) this .wrappedStmt).setNull(
0779: parameterName, sqlType);
0780: } else {
0781: throw SQLError.createSQLException(
0782: "No operations allowed after statement closed",
0783: SQLError.SQL_STATE_GENERAL_ERROR);
0784: }
0785: } catch (SQLException sqlEx) {
0786: checkAndFireConnectionError(sqlEx);
0787: }
0788: }
0789:
0790: /*
0791: * (non-Javadoc)
0792: *
0793: * @see java.sql.CallableStatement#setBoolean(java.lang.String, boolean)
0794: */
0795: public void setBoolean(String parameterName, boolean x)
0796: throws SQLException {
0797: try {
0798: if (this .wrappedStmt != null) {
0799: ((CallableStatement) this .wrappedStmt).setBoolean(
0800: parameterName, x);
0801: } else {
0802: throw SQLError.createSQLException(
0803: "No operations allowed after statement closed",
0804: SQLError.SQL_STATE_GENERAL_ERROR);
0805: }
0806: } catch (SQLException sqlEx) {
0807: checkAndFireConnectionError(sqlEx);
0808: }
0809: }
0810:
0811: /*
0812: * (non-Javadoc)
0813: *
0814: * @see java.sql.CallableStatement#setByte(java.lang.String, byte)
0815: */
0816: public void setByte(String parameterName, byte x)
0817: throws SQLException {
0818: try {
0819: if (this .wrappedStmt != null) {
0820: ((CallableStatement) this .wrappedStmt).setByte(
0821: parameterName, x);
0822: } else {
0823: throw SQLError.createSQLException(
0824: "No operations allowed after statement closed",
0825: SQLError.SQL_STATE_GENERAL_ERROR);
0826: }
0827: } catch (SQLException sqlEx) {
0828: checkAndFireConnectionError(sqlEx);
0829: }
0830: }
0831:
0832: /*
0833: * (non-Javadoc)
0834: *
0835: * @see java.sql.CallableStatement#setShort(java.lang.String, short)
0836: */
0837: public void setShort(String parameterName, short x)
0838: throws SQLException {
0839: try {
0840: if (this .wrappedStmt != null) {
0841: ((CallableStatement) this .wrappedStmt).setShort(
0842: parameterName, x);
0843: } else {
0844: throw SQLError.createSQLException(
0845: "No operations allowed after statement closed",
0846: SQLError.SQL_STATE_GENERAL_ERROR);
0847: }
0848: } catch (SQLException sqlEx) {
0849: checkAndFireConnectionError(sqlEx);
0850: }
0851: }
0852:
0853: /*
0854: * (non-Javadoc)
0855: *
0856: * @see java.sql.CallableStatement#setInt(java.lang.String, int)
0857: */
0858: public void setInt(String parameterName, int x) throws SQLException {
0859: try {
0860: if (this .wrappedStmt != null) {
0861: ((CallableStatement) this .wrappedStmt).setInt(
0862: parameterName, x);
0863: } else {
0864: throw SQLError.createSQLException(
0865: "No operations allowed after statement closed",
0866: SQLError.SQL_STATE_GENERAL_ERROR);
0867: }
0868: } catch (SQLException sqlEx) {
0869: checkAndFireConnectionError(sqlEx);
0870: }
0871: }
0872:
0873: /*
0874: * (non-Javadoc)
0875: *
0876: * @see java.sql.CallableStatement#setLong(java.lang.String, long)
0877: */
0878: public void setLong(String parameterName, long x)
0879: throws SQLException {
0880: try {
0881: if (this .wrappedStmt != null) {
0882: ((CallableStatement) this .wrappedStmt).setLong(
0883: parameterName, x);
0884: } else {
0885: throw SQLError.createSQLException(
0886: "No operations allowed after statement closed",
0887: SQLError.SQL_STATE_GENERAL_ERROR);
0888: }
0889: } catch (SQLException sqlEx) {
0890: checkAndFireConnectionError(sqlEx);
0891: }
0892: }
0893:
0894: /*
0895: * (non-Javadoc)
0896: *
0897: * @see java.sql.CallableStatement#setFloat(java.lang.String, float)
0898: */
0899: public void setFloat(String parameterName, float x)
0900: throws SQLException {
0901: try {
0902: if (this .wrappedStmt != null) {
0903: ((CallableStatement) this .wrappedStmt).setFloat(
0904: parameterName, x);
0905: } else {
0906: throw SQLError.createSQLException(
0907: "No operations allowed after statement closed",
0908: SQLError.SQL_STATE_GENERAL_ERROR);
0909: }
0910: } catch (SQLException sqlEx) {
0911: checkAndFireConnectionError(sqlEx);
0912: }
0913: }
0914:
0915: /*
0916: * (non-Javadoc)
0917: *
0918: * @see java.sql.CallableStatement#setDouble(java.lang.String, double)
0919: */
0920: public void setDouble(String parameterName, double x)
0921: throws SQLException {
0922: try {
0923: if (this .wrappedStmt != null) {
0924: ((CallableStatement) this .wrappedStmt).setDouble(
0925: parameterName, x);
0926: } else {
0927: throw SQLError.createSQLException(
0928: "No operations allowed after statement closed",
0929: SQLError.SQL_STATE_GENERAL_ERROR);
0930: }
0931: } catch (SQLException sqlEx) {
0932: checkAndFireConnectionError(sqlEx);
0933: }
0934: }
0935:
0936: /*
0937: * (non-Javadoc)
0938: *
0939: * @see java.sql.CallableStatement#setBigDecimal(java.lang.String,
0940: * java.math.BigDecimal)
0941: */
0942: public void setBigDecimal(String parameterName, BigDecimal x)
0943: throws SQLException {
0944: try {
0945: if (this .wrappedStmt != null) {
0946: ((CallableStatement) this .wrappedStmt).setBigDecimal(
0947: parameterName, x);
0948: } else {
0949: throw SQLError.createSQLException(
0950: "No operations allowed after statement closed",
0951: SQLError.SQL_STATE_GENERAL_ERROR);
0952: }
0953: } catch (SQLException sqlEx) {
0954: checkAndFireConnectionError(sqlEx);
0955: }
0956: }
0957:
0958: /*
0959: * (non-Javadoc)
0960: *
0961: * @see java.sql.CallableStatement#setString(java.lang.String,
0962: * java.lang.String)
0963: */
0964: public void setString(String parameterName, String x)
0965: throws SQLException {
0966: try {
0967: if (this .wrappedStmt != null) {
0968: ((CallableStatement) this .wrappedStmt).setString(
0969: parameterName, x);
0970: } else {
0971: throw SQLError.createSQLException(
0972: "No operations allowed after statement closed",
0973: SQLError.SQL_STATE_GENERAL_ERROR);
0974: }
0975: } catch (SQLException sqlEx) {
0976: checkAndFireConnectionError(sqlEx);
0977: }
0978: }
0979:
0980: /*
0981: * (non-Javadoc)
0982: *
0983: * @see java.sql.CallableStatement#setBytes(java.lang.String, byte[])
0984: */
0985: public void setBytes(String parameterName, byte[] x)
0986: throws SQLException {
0987: try {
0988: if (this .wrappedStmt != null) {
0989: ((CallableStatement) this .wrappedStmt).setBytes(
0990: parameterName, x);
0991: } else {
0992: throw SQLError.createSQLException(
0993: "No operations allowed after statement closed",
0994: SQLError.SQL_STATE_GENERAL_ERROR);
0995: }
0996: } catch (SQLException sqlEx) {
0997: checkAndFireConnectionError(sqlEx);
0998: }
0999: }
1000:
1001: /*
1002: * (non-Javadoc)
1003: *
1004: * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date)
1005: */
1006: public void setDate(String parameterName, Date x)
1007: throws SQLException {
1008: try {
1009: if (this .wrappedStmt != null) {
1010: ((CallableStatement) this .wrappedStmt).setDate(
1011: parameterName, x);
1012: } else {
1013: throw SQLError.createSQLException(
1014: "No operations allowed after statement closed",
1015: SQLError.SQL_STATE_GENERAL_ERROR);
1016: }
1017: } catch (SQLException sqlEx) {
1018: checkAndFireConnectionError(sqlEx);
1019: }
1020: }
1021:
1022: /*
1023: * (non-Javadoc)
1024: *
1025: * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time)
1026: */
1027: public void setTime(String parameterName, Time x)
1028: throws SQLException {
1029: try {
1030: if (this .wrappedStmt != null) {
1031: ((CallableStatement) this .wrappedStmt).setTime(
1032: parameterName, x);
1033: } else {
1034: throw SQLError.createSQLException(
1035: "No operations allowed after statement closed",
1036: SQLError.SQL_STATE_GENERAL_ERROR);
1037: }
1038: } catch (SQLException sqlEx) {
1039: checkAndFireConnectionError(sqlEx);
1040: }
1041: }
1042:
1043: /*
1044: * (non-Javadoc)
1045: *
1046: * @see java.sql.CallableStatement#setTimestamp(java.lang.String,
1047: * java.sql.Timestamp)
1048: */
1049: public void setTimestamp(String parameterName, Timestamp x)
1050: throws SQLException {
1051: try {
1052: if (this .wrappedStmt != null) {
1053: ((CallableStatement) this .wrappedStmt).setTimestamp(
1054: parameterName, x);
1055: } else {
1056: throw SQLError.createSQLException(
1057: "No operations allowed after statement closed",
1058: SQLError.SQL_STATE_GENERAL_ERROR);
1059: }
1060: } catch (SQLException sqlEx) {
1061: checkAndFireConnectionError(sqlEx);
1062: }
1063: }
1064:
1065: /*
1066: * (non-Javadoc)
1067: *
1068: * @see java.sql.CallableStatement#setAsciiStream(java.lang.String,
1069: * java.io.InputStream, int)
1070: */
1071: public void setAsciiStream(String parameterName, InputStream x,
1072: int length) throws SQLException {
1073: try {
1074: if (this .wrappedStmt != null) {
1075: ((CallableStatement) this .wrappedStmt).setAsciiStream(
1076: parameterName, x, length);
1077: } else {
1078: throw SQLError.createSQLException(
1079: "No operations allowed after statement closed",
1080: SQLError.SQL_STATE_GENERAL_ERROR);
1081: }
1082: } catch (SQLException sqlEx) {
1083: checkAndFireConnectionError(sqlEx);
1084: }
1085:
1086: }
1087:
1088: /*
1089: * (non-Javadoc)
1090: *
1091: * @see java.sql.CallableStatement#setBinaryStream(java.lang.String,
1092: * java.io.InputStream, int)
1093: */
1094: public void setBinaryStream(String parameterName, InputStream x,
1095: int length) throws SQLException {
1096: try {
1097: if (this .wrappedStmt != null) {
1098: ((CallableStatement) this .wrappedStmt).setBinaryStream(
1099: parameterName, x, length);
1100: } else {
1101: throw SQLError.createSQLException(
1102: "No operations allowed after statement closed",
1103: SQLError.SQL_STATE_GENERAL_ERROR);
1104: }
1105: } catch (SQLException sqlEx) {
1106: checkAndFireConnectionError(sqlEx);
1107: }
1108: }
1109:
1110: /*
1111: * (non-Javadoc)
1112: *
1113: * @see java.sql.CallableStatement#setObject(java.lang.String,
1114: * java.lang.Object, int, int)
1115: */
1116: public void setObject(String parameterName, Object x,
1117: int targetSqlType, int scale) throws SQLException {
1118: try {
1119: if (this .wrappedStmt != null) {
1120: ((CallableStatement) this .wrappedStmt).setObject(
1121: parameterName, x, targetSqlType, scale);
1122: } else {
1123: throw SQLError.createSQLException(
1124: "No operations allowed after statement closed",
1125: SQLError.SQL_STATE_GENERAL_ERROR);
1126: }
1127: } catch (SQLException sqlEx) {
1128: checkAndFireConnectionError(sqlEx);
1129: }
1130: }
1131:
1132: /*
1133: * (non-Javadoc)
1134: *
1135: * @see java.sql.CallableStatement#setObject(java.lang.String,
1136: * java.lang.Object, int)
1137: */
1138: public void setObject(String parameterName, Object x,
1139: int targetSqlType) throws SQLException {
1140: try {
1141: if (this .wrappedStmt != null) {
1142: ((CallableStatement) this .wrappedStmt).setObject(
1143: parameterName, x, targetSqlType);
1144: } else {
1145: throw SQLError.createSQLException(
1146: "No operations allowed after statement closed",
1147: SQLError.SQL_STATE_GENERAL_ERROR);
1148: }
1149: } catch (SQLException sqlEx) {
1150: checkAndFireConnectionError(sqlEx);
1151: }
1152: }
1153:
1154: /*
1155: * (non-Javadoc)
1156: *
1157: * @see java.sql.CallableStatement#setObject(java.lang.String,
1158: * java.lang.Object)
1159: */
1160: public void setObject(String parameterName, Object x)
1161: throws SQLException {
1162: try {
1163: if (this .wrappedStmt != null) {
1164: ((CallableStatement) this .wrappedStmt).setObject(
1165: parameterName, x);
1166: } else {
1167: throw SQLError.createSQLException(
1168: "No operations allowed after statement closed",
1169: SQLError.SQL_STATE_GENERAL_ERROR);
1170: }
1171: } catch (SQLException sqlEx) {
1172: checkAndFireConnectionError(sqlEx);
1173: }
1174: }
1175:
1176: /*
1177: * (non-Javadoc)
1178: *
1179: * @see java.sql.CallableStatement#setCharacterStream(java.lang.String,
1180: * java.io.Reader, int)
1181: */
1182: public void setCharacterStream(String parameterName, Reader reader,
1183: int length) throws SQLException {
1184: try {
1185: if (this .wrappedStmt != null) {
1186: ((CallableStatement) this .wrappedStmt)
1187: .setCharacterStream(parameterName, reader,
1188: length);
1189: } else {
1190: throw SQLError.createSQLException(
1191: "No operations allowed after statement closed",
1192: SQLError.SQL_STATE_GENERAL_ERROR);
1193: }
1194: } catch (SQLException sqlEx) {
1195: checkAndFireConnectionError(sqlEx);
1196: }
1197: }
1198:
1199: /*
1200: * (non-Javadoc)
1201: *
1202: * @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date,
1203: * java.util.Calendar)
1204: */
1205: public void setDate(String parameterName, Date x, Calendar cal)
1206: throws SQLException {
1207: try {
1208: if (this .wrappedStmt != null) {
1209: ((CallableStatement) this .wrappedStmt).setDate(
1210: parameterName, x, cal);
1211: } else {
1212: throw SQLError.createSQLException(
1213: "No operations allowed after statement closed",
1214: SQLError.SQL_STATE_GENERAL_ERROR);
1215: }
1216: } catch (SQLException sqlEx) {
1217: checkAndFireConnectionError(sqlEx);
1218: }
1219: }
1220:
1221: /*
1222: * (non-Javadoc)
1223: *
1224: * @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time,
1225: * java.util.Calendar)
1226: */
1227: public void setTime(String parameterName, Time x, Calendar cal)
1228: throws SQLException {
1229: try {
1230: if (this .wrappedStmt != null) {
1231: ((CallableStatement) this .wrappedStmt).setTime(
1232: parameterName, x, cal);
1233: } else {
1234: throw SQLError.createSQLException(
1235: "No operations allowed after statement closed",
1236: SQLError.SQL_STATE_GENERAL_ERROR);
1237: }
1238: } catch (SQLException sqlEx) {
1239: checkAndFireConnectionError(sqlEx);
1240: }
1241: }
1242:
1243: /*
1244: * (non-Javadoc)
1245: *
1246: * @see java.sql.CallableStatement#setTimestamp(java.lang.String,
1247: * java.sql.Timestamp, java.util.Calendar)
1248: */
1249: public void setTimestamp(String parameterName, Timestamp x,
1250: Calendar cal) throws SQLException {
1251: try {
1252: if (this .wrappedStmt != null) {
1253: ((CallableStatement) this .wrappedStmt).setTimestamp(
1254: parameterName, x, cal);
1255: } else {
1256: throw SQLError.createSQLException(
1257: "No operations allowed after statement closed",
1258: SQLError.SQL_STATE_GENERAL_ERROR);
1259: }
1260: } catch (SQLException sqlEx) {
1261: checkAndFireConnectionError(sqlEx);
1262: }
1263: }
1264:
1265: /*
1266: * (non-Javadoc)
1267: *
1268: * @see java.sql.CallableStatement#setNull(java.lang.String, int,
1269: * java.lang.String)
1270: */
1271: public void setNull(String parameterName, int sqlType,
1272: String typeName) throws SQLException {
1273: try {
1274: if (this .wrappedStmt != null) {
1275: ((CallableStatement) this .wrappedStmt).setNull(
1276: parameterName, sqlType, typeName);
1277: } else {
1278: throw SQLError.createSQLException(
1279: "No operations allowed after statement closed",
1280: SQLError.SQL_STATE_GENERAL_ERROR);
1281: }
1282: } catch (SQLException sqlEx) {
1283: checkAndFireConnectionError(sqlEx);
1284: }
1285: }
1286:
1287: /*
1288: * (non-Javadoc)
1289: *
1290: * @see java.sql.CallableStatement#getString(int)
1291: */
1292: public String getString(String parameterName) throws SQLException {
1293: try {
1294: if (this .wrappedStmt != null) {
1295: return ((CallableStatement) this .wrappedStmt)
1296: .getString(parameterName);
1297: } else {
1298: throw SQLError.createSQLException(
1299: "No operations allowed after statement closed",
1300: SQLError.SQL_STATE_GENERAL_ERROR);
1301: }
1302: } catch (SQLException sqlEx) {
1303: checkAndFireConnectionError(sqlEx);
1304: }
1305: return null;
1306: }
1307:
1308: /*
1309: * (non-Javadoc)
1310: *
1311: * @see java.sql.CallableStatement#getBoolean(int)
1312: */
1313: public boolean getBoolean(String parameterName) throws SQLException {
1314: try {
1315: if (this .wrappedStmt != null) {
1316: return ((CallableStatement) this .wrappedStmt)
1317: .getBoolean(parameterName);
1318: } else {
1319: throw SQLError.createSQLException(
1320: "No operations allowed after statement closed",
1321: SQLError.SQL_STATE_GENERAL_ERROR);
1322: }
1323: } catch (SQLException sqlEx) {
1324: checkAndFireConnectionError(sqlEx);
1325: }
1326:
1327: return false;
1328: }
1329:
1330: /*
1331: * (non-Javadoc)
1332: *
1333: * @see java.sql.CallableStatement#getByte(int)
1334: */
1335: public byte getByte(String parameterName) throws SQLException {
1336: try {
1337: if (this .wrappedStmt != null) {
1338: return ((CallableStatement) this .wrappedStmt)
1339: .getByte(parameterName);
1340: } else {
1341: throw SQLError.createSQLException(
1342: "No operations allowed after statement closed",
1343: SQLError.SQL_STATE_GENERAL_ERROR);
1344: }
1345: } catch (SQLException sqlEx) {
1346: checkAndFireConnectionError(sqlEx);
1347: }
1348:
1349: return 0;
1350: }
1351:
1352: /*
1353: * (non-Javadoc)
1354: *
1355: * @see java.sql.CallableStatement#getShort(int)
1356: */
1357: public short getShort(String parameterName) throws SQLException {
1358: try {
1359: if (this .wrappedStmt != null) {
1360: return ((CallableStatement) this .wrappedStmt)
1361: .getShort(parameterName);
1362: } else {
1363: throw SQLError.createSQLException(
1364: "No operations allowed after statement closed",
1365: SQLError.SQL_STATE_GENERAL_ERROR);
1366: }
1367: } catch (SQLException sqlEx) {
1368: checkAndFireConnectionError(sqlEx);
1369: }
1370:
1371: return 0;
1372: }
1373:
1374: /*
1375: * (non-Javadoc)
1376: *
1377: * @see java.sql.CallableStatement#getInt(int)
1378: */
1379: public int getInt(String parameterName) throws SQLException {
1380: try {
1381: if (this .wrappedStmt != null) {
1382: return ((CallableStatement) this .wrappedStmt)
1383: .getInt(parameterName);
1384: } else {
1385: throw SQLError.createSQLException(
1386: "No operations allowed after statement closed",
1387: SQLError.SQL_STATE_GENERAL_ERROR);
1388: }
1389: } catch (SQLException sqlEx) {
1390: checkAndFireConnectionError(sqlEx);
1391: }
1392:
1393: return 0;
1394: }
1395:
1396: /*
1397: * (non-Javadoc)
1398: *
1399: * @see java.sql.CallableStatement#getLong(int)
1400: */
1401: public long getLong(String parameterName) throws SQLException {
1402: try {
1403: if (this .wrappedStmt != null) {
1404: return ((CallableStatement) this .wrappedStmt)
1405: .getLong(parameterName);
1406: } else {
1407: throw SQLError.createSQLException(
1408: "No operations allowed after statement closed",
1409: SQLError.SQL_STATE_GENERAL_ERROR);
1410: }
1411: } catch (SQLException sqlEx) {
1412: checkAndFireConnectionError(sqlEx);
1413: }
1414:
1415: return 0;
1416: }
1417:
1418: /*
1419: * (non-Javadoc)
1420: *
1421: * @see java.sql.CallableStatement#getFloat(int)
1422: */
1423: public float getFloat(String parameterName) throws SQLException {
1424: try {
1425: if (this .wrappedStmt != null) {
1426: return ((CallableStatement) this .wrappedStmt)
1427: .getFloat(parameterName);
1428: } else {
1429: throw SQLError.createSQLException(
1430: "No operations allowed after statement closed",
1431: SQLError.SQL_STATE_GENERAL_ERROR);
1432: }
1433: } catch (SQLException sqlEx) {
1434: checkAndFireConnectionError(sqlEx);
1435: }
1436:
1437: return 0;
1438: }
1439:
1440: /*
1441: * (non-Javadoc)
1442: *
1443: * @see java.sql.CallableStatement#getDouble(int)
1444: */
1445: public double getDouble(String parameterName) throws SQLException {
1446: try {
1447: if (this .wrappedStmt != null) {
1448: return ((CallableStatement) this .wrappedStmt)
1449: .getDouble(parameterName);
1450: } else {
1451: throw SQLError.createSQLException(
1452: "No operations allowed after statement closed",
1453: SQLError.SQL_STATE_GENERAL_ERROR);
1454: }
1455: } catch (SQLException sqlEx) {
1456: checkAndFireConnectionError(sqlEx);
1457: }
1458:
1459: return 0;
1460: }
1461:
1462: /*
1463: * (non-Javadoc)
1464: *
1465: * @see java.sql.CallableStatement#getBytes(int)
1466: */
1467: public byte[] getBytes(String parameterName) throws SQLException {
1468: try {
1469: if (this .wrappedStmt != null) {
1470: return ((CallableStatement) this .wrappedStmt)
1471: .getBytes(parameterName);
1472: } else {
1473: throw SQLError.createSQLException(
1474: "No operations allowed after statement closed",
1475: SQLError.SQL_STATE_GENERAL_ERROR);
1476: }
1477: } catch (SQLException sqlEx) {
1478: checkAndFireConnectionError(sqlEx);
1479: }
1480:
1481: return null;
1482: }
1483:
1484: /*
1485: * (non-Javadoc)
1486: *
1487: * @see java.sql.CallableStatement#getDate(int)
1488: */
1489: public Date getDate(String parameterName) throws SQLException {
1490: try {
1491: if (this .wrappedStmt != null) {
1492: return ((CallableStatement) this .wrappedStmt)
1493: .getDate(parameterName);
1494: } else {
1495: throw SQLError.createSQLException(
1496: "No operations allowed after statement closed",
1497: SQLError.SQL_STATE_GENERAL_ERROR);
1498: }
1499: } catch (SQLException sqlEx) {
1500: checkAndFireConnectionError(sqlEx);
1501: }
1502:
1503: return null;
1504: }
1505:
1506: /*
1507: * (non-Javadoc)
1508: *
1509: * @see java.sql.CallableStatement#getTime(int)
1510: */
1511: public Time getTime(String parameterName) throws SQLException {
1512: try {
1513: if (this .wrappedStmt != null) {
1514: return ((CallableStatement) this .wrappedStmt)
1515: .getTime(parameterName);
1516: } else {
1517: throw SQLError.createSQLException(
1518: "No operations allowed after statement closed",
1519: SQLError.SQL_STATE_GENERAL_ERROR);
1520: }
1521: } catch (SQLException sqlEx) {
1522: checkAndFireConnectionError(sqlEx);
1523: }
1524:
1525: return null;
1526: }
1527:
1528: /*
1529: * (non-Javadoc)
1530: *
1531: * @see java.sql.CallableStatement#getTimestamp(int)
1532: */
1533: public Timestamp getTimestamp(String parameterName)
1534: throws SQLException {
1535: try {
1536: if (this .wrappedStmt != null) {
1537: return ((CallableStatement) this .wrappedStmt)
1538: .getTimestamp(parameterName);
1539: } else {
1540: throw SQLError.createSQLException(
1541: "No operations allowed after statement closed",
1542: SQLError.SQL_STATE_GENERAL_ERROR);
1543: }
1544: } catch (SQLException sqlEx) {
1545: checkAndFireConnectionError(sqlEx);
1546: }
1547:
1548: return null;
1549: }
1550:
1551: /*
1552: * (non-Javadoc)
1553: *
1554: * @see java.sql.CallableStatement#getObject(int)
1555: */
1556: public Object getObject(String parameterName) throws SQLException {
1557: try {
1558: if (this .wrappedStmt != null) {
1559: return ((CallableStatement) this .wrappedStmt)
1560: .getObject(parameterName);
1561: } else {
1562: throw SQLError.createSQLException(
1563: "No operations allowed after statement closed",
1564: SQLError.SQL_STATE_GENERAL_ERROR);
1565: }
1566: } catch (SQLException sqlEx) {
1567: checkAndFireConnectionError(sqlEx);
1568: }
1569:
1570: return null;
1571: }
1572:
1573: /*
1574: * (non-Javadoc)
1575: *
1576: * @see java.sql.CallableStatement#getBigDecimal(int)
1577: */
1578: public BigDecimal getBigDecimal(String parameterName)
1579: throws SQLException {
1580: try {
1581: if (this .wrappedStmt != null) {
1582: return ((CallableStatement) this .wrappedStmt)
1583: .getBigDecimal(parameterName);
1584: } else {
1585: throw SQLError.createSQLException(
1586: "No operations allowed after statement closed",
1587: SQLError.SQL_STATE_GENERAL_ERROR);
1588: }
1589: } catch (SQLException sqlEx) {
1590: checkAndFireConnectionError(sqlEx);
1591: }
1592:
1593: return null;
1594: }
1595:
1596: /*
1597: * (non-Javadoc)
1598: *
1599: * @see java.sql.CallableStatement#getObject(int, java.util.Map)
1600: */
1601: public Object getObject(String parameterName, Map typeMap)
1602: throws SQLException {
1603: try {
1604: if (this .wrappedStmt != null) {
1605: return ((CallableStatement) this .wrappedStmt)
1606: .getObject(parameterName, typeMap);
1607: } else {
1608: throw SQLError.createSQLException(
1609: "No operations allowed after statement closed",
1610: SQLError.SQL_STATE_GENERAL_ERROR);
1611: }
1612: } catch (SQLException sqlEx) {
1613: checkAndFireConnectionError(sqlEx);
1614: }
1615: return null;
1616: }
1617:
1618: /*
1619: * (non-Javadoc)
1620: *
1621: * @see java.sql.CallableStatement#getRef(int)
1622: */
1623: public Ref getRef(String parameterName) throws SQLException {
1624: try {
1625: if (this .wrappedStmt != null) {
1626: return ((CallableStatement) this .wrappedStmt)
1627: .getRef(parameterName);
1628: } else {
1629: throw SQLError.createSQLException(
1630: "No operations allowed after statement closed",
1631: SQLError.SQL_STATE_GENERAL_ERROR);
1632: }
1633: } catch (SQLException sqlEx) {
1634: checkAndFireConnectionError(sqlEx);
1635: }
1636:
1637: return null;
1638: }
1639:
1640: /*
1641: * (non-Javadoc)
1642: *
1643: * @see java.sql.CallableStatement#getBlob(int)
1644: */
1645: public Blob getBlob(String parameterName) throws SQLException {
1646: try {
1647: if (this .wrappedStmt != null) {
1648: return ((CallableStatement) this .wrappedStmt)
1649: .getBlob(parameterName);
1650: } else {
1651: throw SQLError.createSQLException(
1652: "No operations allowed after statement closed",
1653: SQLError.SQL_STATE_GENERAL_ERROR);
1654: }
1655: } catch (SQLException sqlEx) {
1656: checkAndFireConnectionError(sqlEx);
1657: }
1658:
1659: return null;
1660: }
1661:
1662: /*
1663: * (non-Javadoc)
1664: *
1665: * @see java.sql.CallableStatement#getClob(int)
1666: */
1667: public Clob getClob(String parameterName) throws SQLException {
1668: try {
1669: if (this .wrappedStmt != null) {
1670: return ((CallableStatement) this .wrappedStmt)
1671: .getClob(parameterName);
1672: } else {
1673: throw SQLError.createSQLException(
1674: "No operations allowed after statement closed",
1675: SQLError.SQL_STATE_GENERAL_ERROR);
1676: }
1677: } catch (SQLException sqlEx) {
1678: checkAndFireConnectionError(sqlEx);
1679: }
1680: return null;
1681: }
1682:
1683: /*
1684: * (non-Javadoc)
1685: *
1686: * @see java.sql.CallableStatement#getArray(int)
1687: */
1688: public Array getArray(String parameterName) throws SQLException {
1689: try {
1690: if (this .wrappedStmt != null) {
1691: return ((CallableStatement) this .wrappedStmt)
1692: .getArray(parameterName);
1693: } else {
1694: throw SQLError.createSQLException(
1695: "No operations allowed after statement closed",
1696: SQLError.SQL_STATE_GENERAL_ERROR);
1697: }
1698: } catch (SQLException sqlEx) {
1699: checkAndFireConnectionError(sqlEx);
1700: }
1701: return null;
1702: }
1703:
1704: /*
1705: * (non-Javadoc)
1706: *
1707: * @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
1708: */
1709: public Date getDate(String parameterName, Calendar cal)
1710: throws SQLException {
1711: try {
1712: if (this .wrappedStmt != null) {
1713: return ((CallableStatement) this .wrappedStmt).getDate(
1714: parameterName, cal);
1715: } else {
1716: throw SQLError.createSQLException(
1717: "No operations allowed after statement closed",
1718: SQLError.SQL_STATE_GENERAL_ERROR);
1719: }
1720: } catch (SQLException sqlEx) {
1721: checkAndFireConnectionError(sqlEx);
1722: }
1723: return null;
1724: }
1725:
1726: /*
1727: * (non-Javadoc)
1728: *
1729: * @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
1730: */
1731: public Time getTime(String parameterName, Calendar cal)
1732: throws SQLException {
1733: try {
1734: if (this .wrappedStmt != null) {
1735: return ((CallableStatement) this .wrappedStmt).getTime(
1736: parameterName, cal);
1737: } else {
1738: throw SQLError.createSQLException(
1739: "No operations allowed after statement closed",
1740: SQLError.SQL_STATE_GENERAL_ERROR);
1741: }
1742: } catch (SQLException sqlEx) {
1743: checkAndFireConnectionError(sqlEx);
1744: }
1745: return null;
1746: }
1747:
1748: /*
1749: * (non-Javadoc)
1750: *
1751: * @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
1752: */
1753: public Timestamp getTimestamp(String parameterName, Calendar cal)
1754: throws SQLException {
1755: try {
1756: if (this .wrappedStmt != null) {
1757: return ((CallableStatement) this .wrappedStmt)
1758: .getTimestamp(parameterName, cal);
1759: } else {
1760: throw SQLError.createSQLException(
1761: "No operations allowed after statement closed",
1762: SQLError.SQL_STATE_GENERAL_ERROR);
1763: }
1764: } catch (SQLException sqlEx) {
1765: checkAndFireConnectionError(sqlEx);
1766: }
1767: return null;
1768: }
1769:
1770: /*
1771: * (non-Javadoc)
1772: *
1773: * @see java.sql.CallableStatement#getURL(java.lang.String)
1774: */
1775: public URL getURL(String parameterName) throws SQLException {
1776: try {
1777: if (this .wrappedStmt != null) {
1778: return ((CallableStatement) this .wrappedStmt)
1779: .getURL(parameterName);
1780: } else {
1781: throw SQLError.createSQLException(
1782: "No operations allowed after statement closed",
1783: SQLError.SQL_STATE_GENERAL_ERROR);
1784: }
1785: } catch (SQLException sqlEx) {
1786: checkAndFireConnectionError(sqlEx);
1787: }
1788:
1789: return null;
1790: }
1791: //
1792: // public Reader getCharacterStream(int parameterIndex) throws SQLException {
1793: // try {
1794: // if (this.wrappedStmt != null) {
1795: // return ((CallableStatement) this.wrappedStmt)
1796: // .getCharacterStream(parameterIndex);
1797: // } else {
1798: // throw SQLError.createSQLException(
1799: // "No operations allowed after statement closed",
1800: // SQLError.SQL_STATE_GENERAL_ERROR);
1801: // }
1802: // } catch (SQLException sqlEx) {
1803: // checkAndFireConnectionError(sqlEx);
1804: // }
1805: //
1806: // return null;
1807: // }
1808: //
1809: // public Reader getCharacterStream(String parameterName) throws SQLException {
1810: // try {
1811: // if (this.wrappedStmt != null) {
1812: // return ((CallableStatement) this.wrappedStmt)
1813: // .getCharacterStream(parameterName);
1814: // } else {
1815: // throw SQLError.createSQLException(
1816: // "No operations allowed after statement closed",
1817: // SQLError.SQL_STATE_GENERAL_ERROR);
1818: // }
1819: // } catch (SQLException sqlEx) {
1820: // checkAndFireConnectionError(sqlEx);
1821: // }
1822: //
1823: // return null;
1824: // }
1825: //
1826: // public Reader getNCharacterStream(int parameterIndex) throws SQLException {
1827: // try {
1828: // if (this.wrappedStmt != null) {
1829: // return ((CallableStatement) this.wrappedStmt)
1830: // .getCharacterStream(parameterIndex);
1831: // } else {
1832: // throw SQLError.createSQLException(
1833: // "No operations allowed after statement closed",
1834: // SQLError.SQL_STATE_GENERAL_ERROR);
1835: // }
1836: // } catch (SQLException sqlEx) {
1837: // checkAndFireConnectionError(sqlEx);
1838: // }
1839: //
1840: // return null;
1841: // }
1842: //
1843: // public Reader getNCharacterStream(String parameterName) throws SQLException {
1844: // try {
1845: // if (this.wrappedStmt != null) {
1846: // return ((CallableStatement) this.wrappedStmt)
1847: // .getNCharacterStream(parameterName);
1848: // } else {
1849: // throw SQLError.createSQLException(
1850: // "No operations allowed after statement closed",
1851: // SQLError.SQL_STATE_GENERAL_ERROR);
1852: // }
1853: // } catch (SQLException sqlEx) {
1854: // checkAndFireConnectionError(sqlEx);
1855: // }
1856: //
1857: // return null;
1858: // }
1859: //
1860: // public NClob getNClob(int parameterIndex) throws SQLException {
1861: // try {
1862: // if (this.wrappedStmt != null) {
1863: // return ((CallableStatement) this.wrappedStmt)
1864: // .getNClob(parameterIndex);
1865: // } else {
1866: // throw SQLError.createSQLException(
1867: // "No operations allowed after statement closed",
1868: // SQLError.SQL_STATE_GENERAL_ERROR);
1869: // }
1870: // } catch (SQLException sqlEx) {
1871: // checkAndFireConnectionError(sqlEx);
1872: // }
1873: //
1874: // return null;
1875: // }
1876: //
1877: // public NClob getNClob(String parameterName) throws SQLException {
1878: // try {
1879: // if (this.wrappedStmt != null) {
1880: // return ((CallableStatement) this.wrappedStmt)
1881: // .getNClob(parameterName);
1882: // } else {
1883: // throw SQLError.createSQLException(
1884: // "No operations allowed after statement closed",
1885: // SQLError.SQL_STATE_GENERAL_ERROR);
1886: // }
1887: // } catch (SQLException sqlEx) {
1888: // checkAndFireConnectionError(sqlEx);
1889: // }
1890: //
1891: // return null;
1892: // }
1893: //
1894: // public String getNString(int parameterIndex) throws SQLException {
1895: // try {
1896: // if (this.wrappedStmt != null) {
1897: // return ((CallableStatement) this.wrappedStmt)
1898: // .getNString(parameterIndex);
1899: // } else {
1900: // throw SQLError.createSQLException(
1901: // "No operations allowed after statement closed",
1902: // SQLError.SQL_STATE_GENERAL_ERROR);
1903: // }
1904: // } catch (SQLException sqlEx) {
1905: // checkAndFireConnectionError(sqlEx);
1906: // }
1907: //
1908: // return null;
1909: // }
1910: //
1911: // public String getNString(String parameterName) throws SQLException {
1912: // try {
1913: // if (this.wrappedStmt != null) {
1914: // return ((CallableStatement) this.wrappedStmt)
1915: // .getNString(parameterName);
1916: // } else {
1917: // throw SQLError.createSQLException(
1918: // "No operations allowed after statement closed",
1919: // SQLError.SQL_STATE_GENERAL_ERROR);
1920: // }
1921: // } catch (SQLException sqlEx) {
1922: // checkAndFireConnectionError(sqlEx);
1923: // }
1924: //
1925: // return null;
1926: // }
1927: //
1928: // public RowId getRowId(int parameterIndex) throws SQLException {
1929: // try {
1930: // if (this.wrappedStmt != null) {
1931: // return ((CallableStatement) this.wrappedStmt)
1932: // .getRowId(parameterIndex);
1933: // } else {
1934: // throw SQLError.createSQLException(
1935: // "No operations allowed after statement closed",
1936: // SQLError.SQL_STATE_GENERAL_ERROR);
1937: // }
1938: // } catch (SQLException sqlEx) {
1939: // checkAndFireConnectionError(sqlEx);
1940: // }
1941: //
1942: // return null;
1943: // }
1944: //
1945: // public RowId getRowId(String parameterName) throws SQLException {
1946: // try {
1947: // if (this.wrappedStmt != null) {
1948: // return ((CallableStatement) this.wrappedStmt)
1949: // .getRowId(parameterName);
1950: // } else {
1951: // throw SQLError.createSQLException(
1952: // "No operations allowed after statement closed",
1953: // SQLError.SQL_STATE_GENERAL_ERROR);
1954: // }
1955: // } catch (SQLException sqlEx) {
1956: // checkAndFireConnectionError(sqlEx);
1957: // }
1958: //
1959: // return null;
1960: // }
1961: //
1962: // public SQLXML getSQLXML(int parameterIndex) throws SQLException {
1963: // try {
1964: // if (this.wrappedStmt != null) {
1965: // return ((CallableStatement) this.wrappedStmt)
1966: // .getSQLXML(parameterIndex);
1967: // } else {
1968: // throw SQLError.createSQLException(
1969: // "No operations allowed after statement closed",
1970: // SQLError.SQL_STATE_GENERAL_ERROR);
1971: // }
1972: // } catch (SQLException sqlEx) {
1973: // checkAndFireConnectionError(sqlEx);
1974: // }
1975: //
1976: // return null;
1977: // }
1978: //
1979: // public SQLXML getSQLXML(String parameterName) throws SQLException {
1980: // try {
1981: // if (this.wrappedStmt != null) {
1982: // return ((CallableStatement) this.wrappedStmt)
1983: // .getSQLXML(parameterName);
1984: // } else {
1985: // throw SQLError.createSQLException(
1986: // "No operations allowed after statement closed",
1987: // SQLError.SQL_STATE_GENERAL_ERROR);
1988: // }
1989: // } catch (SQLException sqlEx) {
1990: // checkAndFireConnectionError(sqlEx);
1991: // }
1992: //
1993: // return null;
1994: // }
1995: //
1996: // public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
1997: // try {
1998: // if (this.wrappedStmt != null) {
1999: // ((CallableStatement) this.wrappedStmt)
2000: // .setAsciiStream(parameterName, x) ;
2001: // } else {
2002: // throw SQLError.createSQLException(
2003: // "No operations allowed after statement closed",
2004: // SQLError.SQL_STATE_GENERAL_ERROR);
2005: // }
2006: // } catch (SQLException sqlEx) {
2007: // checkAndFireConnectionError(sqlEx);
2008: // }
2009: // }
2010: //
2011: // public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
2012: // try {
2013: // if (this.wrappedStmt != null) {
2014: // ((CallableStatement) this.wrappedStmt)
2015: // .setAsciiStream(parameterName, x, length);
2016: // } else {
2017: // throw SQLError.createSQLException(
2018: // "No operations allowed after statement closed",
2019: // SQLError.SQL_STATE_GENERAL_ERROR);
2020: // }
2021: // } catch (SQLException sqlEx) {
2022: // checkAndFireConnectionError(sqlEx);
2023: // }
2024: // }
2025: //
2026: // public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
2027: // try {
2028: // if (this.wrappedStmt != null) {
2029: // ((CallableStatement) this.wrappedStmt)
2030: // .setBinaryStream(parameterName, x);
2031: // } else {
2032: // throw SQLError.createSQLException(
2033: // "No operations allowed after statement closed",
2034: // SQLError.SQL_STATE_GENERAL_ERROR);
2035: // }
2036: // } catch (SQLException sqlEx) {
2037: // checkAndFireConnectionError(sqlEx);
2038: // }
2039: // }
2040: //
2041: // public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
2042: // try {
2043: // if (this.wrappedStmt != null) {
2044: // ((CallableStatement) this.wrappedStmt)
2045: // .setBinaryStream(parameterName, x, length);
2046: // } else {
2047: // throw SQLError.createSQLException(
2048: // "No operations allowed after statement closed",
2049: // SQLError.SQL_STATE_GENERAL_ERROR);
2050: // }
2051: // } catch (SQLException sqlEx) {
2052: // checkAndFireConnectionError(sqlEx);
2053: // }
2054: // }
2055: //
2056: // public void setBlob(String parameterName, Blob x) throws SQLException {
2057: // try {
2058: // if (this.wrappedStmt != null) {
2059: // ((CallableStatement) this.wrappedStmt)
2060: // .setBlob(parameterName, x);
2061: // } else {
2062: // throw SQLError.createSQLException(
2063: // "No operations allowed after statement closed",
2064: // SQLError.SQL_STATE_GENERAL_ERROR);
2065: // }
2066: // } catch (SQLException sqlEx) {
2067: // checkAndFireConnectionError(sqlEx);
2068: // }
2069: // }
2070: //
2071: // public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
2072: // try {
2073: // if (this.wrappedStmt != null) {
2074: // ((CallableStatement) this.wrappedStmt)
2075: // .setBlob(parameterName, inputStream);
2076: // } else {
2077: // throw SQLError.createSQLException(
2078: // "No operations allowed after statement closed",
2079: // SQLError.SQL_STATE_GENERAL_ERROR);
2080: // }
2081: // } catch (SQLException sqlEx) {
2082: // checkAndFireConnectionError(sqlEx);
2083: // }
2084: // }
2085: //
2086: // public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
2087: // try {
2088: // if (this.wrappedStmt != null) {
2089: // ((CallableStatement) this.wrappedStmt)
2090: // .setBlob(parameterName, inputStream, length);
2091: // } else {
2092: // throw SQLError.createSQLException(
2093: // "No operations allowed after statement closed",
2094: // SQLError.SQL_STATE_GENERAL_ERROR);
2095: // }
2096: // } catch (SQLException sqlEx) {
2097: // checkAndFireConnectionError(sqlEx);
2098: // }
2099: // }
2100: //
2101: // public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
2102: // try {
2103: // if (this.wrappedStmt != null) {
2104: // ((CallableStatement) this.wrappedStmt)
2105: // .setCharacterStream(parameterName, reader);
2106: // } else {
2107: // throw SQLError.createSQLException(
2108: // "No operations allowed after statement closed",
2109: // SQLError.SQL_STATE_GENERAL_ERROR);
2110: // }
2111: // } catch (SQLException sqlEx) {
2112: // checkAndFireConnectionError(sqlEx);
2113: // }
2114: // }
2115: //
2116: // public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
2117: // try {
2118: // if (this.wrappedStmt != null) {
2119: // ((CallableStatement) this.wrappedStmt)
2120: // .setCharacterStream(parameterName, reader, length);
2121: // } else {
2122: // throw SQLError.createSQLException(
2123: // "No operations allowed after statement closed",
2124: // SQLError.SQL_STATE_GENERAL_ERROR);
2125: // }
2126: // } catch (SQLException sqlEx) {
2127: // checkAndFireConnectionError(sqlEx);
2128: // }
2129: // }
2130: //
2131: // public void setClob(String parameterName, Clob x) throws SQLException {
2132: // try {
2133: // if (this.wrappedStmt != null) {
2134: // ((CallableStatement) this.wrappedStmt)
2135: // .setClob(parameterName, x);
2136: // } else {
2137: // throw SQLError.createSQLException(
2138: // "No operations allowed after statement closed",
2139: // SQLError.SQL_STATE_GENERAL_ERROR);
2140: // }
2141: // } catch (SQLException sqlEx) {
2142: // checkAndFireConnectionError(sqlEx);
2143: // }
2144: // }
2145: //
2146: // public void setClob(String parameterName, Reader reader) throws SQLException {
2147: // try {
2148: // if (this.wrappedStmt != null) {
2149: // ((CallableStatement) this.wrappedStmt)
2150: // .setClob(parameterName, reader);
2151: // } else {
2152: // throw SQLError.createSQLException(
2153: // "No operations allowed after statement closed",
2154: // SQLError.SQL_STATE_GENERAL_ERROR);
2155: // }
2156: // } catch (SQLException sqlEx) {
2157: // checkAndFireConnectionError(sqlEx);
2158: // }
2159: // }
2160: //
2161: // public void setClob(String parameterName, Reader reader, long length) throws SQLException {
2162: // try {
2163: // if (this.wrappedStmt != null) {
2164: // ((CallableStatement) this.wrappedStmt)
2165: // .setClob(parameterName, reader, length);
2166: // } else {
2167: // throw SQLError.createSQLException(
2168: // "No operations allowed after statement closed",
2169: // SQLError.SQL_STATE_GENERAL_ERROR);
2170: // }
2171: // } catch (SQLException sqlEx) {
2172: // checkAndFireConnectionError(sqlEx);
2173: // }
2174: // }
2175: //
2176: // public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
2177: // try {
2178: // if (this.wrappedStmt != null) {
2179: // ((CallableStatement) this.wrappedStmt)
2180: // .setNCharacterStream(parameterName, value);
2181: // } else {
2182: // throw SQLError.createSQLException(
2183: // "No operations allowed after statement closed",
2184: // SQLError.SQL_STATE_GENERAL_ERROR);
2185: // }
2186: // } catch (SQLException sqlEx) {
2187: // checkAndFireConnectionError(sqlEx);
2188: // }
2189: // }
2190: //
2191: // public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
2192: // try {
2193: // if (this.wrappedStmt != null) {
2194: // ((CallableStatement) this.wrappedStmt)
2195: // .setNCharacterStream(parameterName, value, length);
2196: // } else {
2197: // throw SQLError.createSQLException(
2198: // "No operations allowed after statement closed",
2199: // SQLError.SQL_STATE_GENERAL_ERROR);
2200: // }
2201: // } catch (SQLException sqlEx) {
2202: // checkAndFireConnectionError(sqlEx);
2203: // }
2204: // }
2205: //
2206: // public void setNClob(String parameterName, NClob value) throws SQLException {
2207: // try {
2208: // if (this.wrappedStmt != null) {
2209: // ((CallableStatement) this.wrappedStmt)
2210: // .setNClob(parameterName, value);
2211: // } else {
2212: // throw SQLError.createSQLException(
2213: // "No operations allowed after statement closed",
2214: // SQLError.SQL_STATE_GENERAL_ERROR);
2215: // }
2216: // } catch (SQLException sqlEx) {
2217: // checkAndFireConnectionError(sqlEx);
2218: // }
2219: // }
2220: //
2221: // public void setNClob(String parameterName, Reader reader) throws SQLException {
2222: // try {
2223: // if (this.wrappedStmt != null) {
2224: // ((CallableStatement) this.wrappedStmt)
2225: // .setNClob(parameterName, reader);
2226: // } else {
2227: // throw SQLError.createSQLException(
2228: // "No operations allowed after statement closed",
2229: // SQLError.SQL_STATE_GENERAL_ERROR);
2230: // }
2231: // } catch (SQLException sqlEx) {
2232: // checkAndFireConnectionError(sqlEx);
2233: // }
2234: // }
2235: //
2236: // public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
2237: // try {
2238: // if (this.wrappedStmt != null) {
2239: // ((CallableStatement) this.wrappedStmt)
2240: // .setNClob(parameterName, reader, length);
2241: // } else {
2242: // throw SQLError.createSQLException(
2243: // "No operations allowed after statement closed",
2244: // SQLError.SQL_STATE_GENERAL_ERROR);
2245: // }
2246: // } catch (SQLException sqlEx) {
2247: // checkAndFireConnectionError(sqlEx);
2248: // }
2249: // }
2250: //
2251: // public void setNString(String parameterName, String value) throws SQLException {
2252: // try {
2253: // if (this.wrappedStmt != null) {
2254: // ((CallableStatement) this.wrappedStmt)
2255: // .setNString(parameterName, value);
2256: // } else {
2257: // throw SQLError.createSQLException(
2258: // "No operations allowed after statement closed",
2259: // SQLError.SQL_STATE_GENERAL_ERROR);
2260: // }
2261: // } catch (SQLException sqlEx) {
2262: // checkAndFireConnectionError(sqlEx);
2263: // }
2264: // }
2265: //
2266: // public void setRowId(String parameterName, RowId x) throws SQLException {
2267: // try {
2268: // if (this.wrappedStmt != null) {
2269: // ((CallableStatement) this.wrappedStmt)
2270: // .setRowId(parameterName, x);
2271: // } else {
2272: // throw SQLError.createSQLException(
2273: // "No operations allowed after statement closed",
2274: // SQLError.SQL_STATE_GENERAL_ERROR);
2275: // }
2276: // } catch (SQLException sqlEx) {
2277: // checkAndFireConnectionError(sqlEx);
2278: // }
2279: // }
2280: //
2281: // public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
2282: // try {
2283: // if (this.wrappedStmt != null) {
2284: // ((CallableStatement) this.wrappedStmt)
2285: // .setSQLXML(parameterName, xmlObject);
2286: // } else {
2287: // throw SQLError.createSQLException(
2288: // "No operations allowed after statement closed",
2289: // SQLError.SQL_STATE_GENERAL_ERROR);
2290: // }
2291: // } catch (SQLException sqlEx) {
2292: // checkAndFireConnectionError(sqlEx);
2293: // }
2294: // }
2295: //
2296: // public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
2297: // try {
2298: // if (this.wrappedStmt != null) {
2299: // ((CallableStatement) this.wrappedStmt)
2300: // .setAsciiStream(parameterIndex, x);
2301: // } else {
2302: // throw SQLError.createSQLException(
2303: // "No operations allowed after statement closed",
2304: // SQLError.SQL_STATE_GENERAL_ERROR);
2305: // }
2306: // } catch (SQLException sqlEx) {
2307: // checkAndFireConnectionError(sqlEx);
2308: // }
2309: // }
2310: //
2311: // public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
2312: // try {
2313: // if (this.wrappedStmt != null) {
2314: // ((CallableStatement) this.wrappedStmt)
2315: // .setAsciiStream(parameterIndex, x, length);
2316: // } else {
2317: // throw SQLError.createSQLException(
2318: // "No operations allowed after statement closed",
2319: // SQLError.SQL_STATE_GENERAL_ERROR);
2320: // }
2321: // } catch (SQLException sqlEx) {
2322: // checkAndFireConnectionError(sqlEx);
2323: // }
2324: // }
2325: //
2326: // public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
2327: // try {
2328: // if (this.wrappedStmt != null) {
2329: // ((CallableStatement) this.wrappedStmt)
2330: // .setBinaryStream(parameterIndex, x) ;
2331: // } else {
2332: // throw SQLError.createSQLException(
2333: // "No operations allowed after statement closed",
2334: // SQLError.SQL_STATE_GENERAL_ERROR);
2335: // }
2336: // } catch (SQLException sqlEx) {
2337: // checkAndFireConnectionError(sqlEx);
2338: // }
2339: // }
2340: //
2341: // public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
2342: // try {
2343: // if (this.wrappedStmt != null) {
2344: // ((CallableStatement) this.wrappedStmt)
2345: // .setBinaryStream(parameterIndex, x, length);
2346: // } else {
2347: // throw SQLError.createSQLException(
2348: // "No operations allowed after statement closed",
2349: // SQLError.SQL_STATE_GENERAL_ERROR);
2350: // }
2351: // } catch (SQLException sqlEx) {
2352: // checkAndFireConnectionError(sqlEx);
2353: // }
2354: // }
2355: //
2356: // public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
2357: // try {
2358: // if (this.wrappedStmt != null) {
2359: // ((CallableStatement) this.wrappedStmt)
2360: // .setBlob(parameterIndex, inputStream);
2361: // } else {
2362: // throw SQLError.createSQLException(
2363: // "No operations allowed after statement closed",
2364: // SQLError.SQL_STATE_GENERAL_ERROR);
2365: // }
2366: // } catch (SQLException sqlEx) {
2367: // checkAndFireConnectionError(sqlEx);
2368: // }
2369: // }
2370: //
2371: // public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
2372: // try {
2373: // if (this.wrappedStmt != null) {
2374: // ((CallableStatement) this.wrappedStmt)
2375: // .setBlob(parameterIndex, inputStream, length);
2376: // } else {
2377: // throw SQLError.createSQLException(
2378: // "No operations allowed after statement closed",
2379: // SQLError.SQL_STATE_GENERAL_ERROR);
2380: // }
2381: // } catch (SQLException sqlEx) {
2382: // checkAndFireConnectionError(sqlEx);
2383: // }
2384: // }
2385: //
2386: // public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
2387: // try {
2388: // if (this.wrappedStmt != null) {
2389: // ((CallableStatement) this.wrappedStmt)
2390: // .setCharacterStream(parameterIndex, reader);
2391: // } else {
2392: // throw SQLError.createSQLException(
2393: // "No operations allowed after statement closed",
2394: // SQLError.SQL_STATE_GENERAL_ERROR);
2395: // }
2396: // } catch (SQLException sqlEx) {
2397: // checkAndFireConnectionError(sqlEx);
2398: // }
2399: // }
2400: //
2401: // public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
2402: // try {
2403: // if (this.wrappedStmt != null) {
2404: // ((CallableStatement) this.wrappedStmt)
2405: // .getCharacterStream(parameterIndex);
2406: // } else {
2407: // throw SQLError.createSQLException(
2408: // "No operations allowed after statement closed",
2409: // SQLError.SQL_STATE_GENERAL_ERROR);
2410: // }
2411: // } catch (SQLException sqlEx) {
2412: // checkAndFireConnectionError(sqlEx);
2413: // }
2414: // }
2415: //
2416: // public void setClob(int parameterIndex, Reader reader) throws SQLException {
2417: // try {
2418: // if (this.wrappedStmt != null) {
2419: // ((CallableStatement) this.wrappedStmt)
2420: // .setClob(parameterIndex, reader);
2421: // } else {
2422: // throw SQLError.createSQLException(
2423: // "No operations allowed after statement closed",
2424: // SQLError.SQL_STATE_GENERAL_ERROR);
2425: // }
2426: // } catch (SQLException sqlEx) {
2427: // checkAndFireConnectionError(sqlEx);
2428: // }
2429: // }
2430: //
2431: // public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
2432: // try {
2433: // if (this.wrappedStmt != null) {
2434: // ((CallableStatement) this.wrappedStmt)
2435: // .setClob(parameterIndex, reader, length);
2436: // } else {
2437: // throw SQLError.createSQLException(
2438: // "No operations allowed after statement closed",
2439: // SQLError.SQL_STATE_GENERAL_ERROR);
2440: // }
2441: // } catch (SQLException sqlEx) {
2442: // checkAndFireConnectionError(sqlEx);
2443: // }
2444: // }
2445: //
2446: // public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
2447: // try {
2448: // if (this.wrappedStmt != null) {
2449: // ((CallableStatement) this.wrappedStmt)
2450: // .setNCharacterStream(parameterIndex, value);
2451: // } else {
2452: // throw SQLError.createSQLException(
2453: // "No operations allowed after statement closed",
2454: // SQLError.SQL_STATE_GENERAL_ERROR);
2455: // }
2456: // } catch (SQLException sqlEx) {
2457: // checkAndFireConnectionError(sqlEx);
2458: // }
2459: //
2460: // }
2461: //
2462: // public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
2463: // try {
2464: // if (this.wrappedStmt != null) {
2465: // ((CallableStatement) this.wrappedStmt)
2466: // .setNCharacterStream(parameterIndex, value, length);
2467: // } else {
2468: // throw SQLError.createSQLException(
2469: // "No operations allowed after statement closed",
2470: // SQLError.SQL_STATE_GENERAL_ERROR);
2471: // }
2472: // } catch (SQLException sqlEx) {
2473: // checkAndFireConnectionError(sqlEx);
2474: // }
2475: // }
2476: //
2477: // public void setNClob(int parameterIndex, NClob value) throws SQLException {
2478: // try {
2479: // if (this.wrappedStmt != null) {
2480: // ((CallableStatement) this.wrappedStmt)
2481: // .setNClob(parameterIndex, value);
2482: // } else {
2483: // throw SQLError.createSQLException(
2484: // "No operations allowed after statement closed",
2485: // SQLError.SQL_STATE_GENERAL_ERROR);
2486: // }
2487: // } catch (SQLException sqlEx) {
2488: // checkAndFireConnectionError(sqlEx);
2489: // }
2490: // }
2491: //
2492: // public void setNClob(int parameterIndex, Reader reader) throws SQLException {
2493: // try {
2494: // if (this.wrappedStmt != null) {
2495: // ((CallableStatement) this.wrappedStmt)
2496: // .setNClob(parameterIndex, reader);
2497: // } else {
2498: // throw SQLError.createSQLException(
2499: // "No operations allowed after statement closed",
2500: // SQLError.SQL_STATE_GENERAL_ERROR);
2501: // }
2502: // } catch (SQLException sqlEx) {
2503: // checkAndFireConnectionError(sqlEx);
2504: // }
2505: // }
2506: //
2507: // public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
2508: // try {
2509: // if (this.wrappedStmt != null) {
2510: // ((CallableStatement) this.wrappedStmt)
2511: // .setNClob(parameterIndex, reader, length);
2512: // } else {
2513: // throw SQLError.createSQLException(
2514: // "No operations allowed after statement closed",
2515: // SQLError.SQL_STATE_GENERAL_ERROR);
2516: // }
2517: // } catch (SQLException sqlEx) {
2518: // checkAndFireConnectionError(sqlEx);
2519: // }
2520: // }
2521: //
2522: // public void setNString(int parameterIndex, String value) throws SQLException {
2523: // try {
2524: // if (this.wrappedStmt != null) {
2525: // ((CallableStatement) this.wrappedStmt)
2526: // .setNString(parameterIndex, value);
2527: // } else {
2528: // throw SQLError.createSQLException(
2529: // "No operations allowed after statement closed",
2530: // SQLError.SQL_STATE_GENERAL_ERROR);
2531: // }
2532: // } catch (SQLException sqlEx) {
2533: // checkAndFireConnectionError(sqlEx);
2534: // }
2535: // }
2536: //
2537: // public void setRowId(int parameterIndex, RowId x) throws SQLException {
2538: // try {
2539: // if (this.wrappedStmt != null) {
2540: // ((CallableStatement) this.wrappedStmt)
2541: // .setRowId(parameterIndex, x);
2542: // } else {
2543: // throw SQLError.createSQLException(
2544: // "No operations allowed after statement closed",
2545: // SQLError.SQL_STATE_GENERAL_ERROR);
2546: // }
2547: // } catch (SQLException sqlEx) {
2548: // checkAndFireConnectionError(sqlEx);
2549: // }
2550: // }
2551: //
2552: // public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
2553: // try {
2554: // if (this.wrappedStmt != null) {
2555: // ((CallableStatement) this.wrappedStmt)
2556: // .setSQLXML(parameterIndex, xmlObject);
2557: // } else {
2558: // throw SQLError.createSQLException(
2559: // "No operations allowed after statement closed",
2560: // SQLError.SQL_STATE_GENERAL_ERROR);
2561: // }
2562: // } catch (SQLException sqlEx) {
2563: // checkAndFireConnectionError(sqlEx);
2564: // }
2565: //
2566: // }
2567: //
2568: // public boolean isClosed() throws SQLException {
2569: // try {
2570: // if (this.wrappedStmt != null) {
2571: // return ((CallableStatement) this.wrappedStmt)
2572: // .isClosed();
2573: // } else {
2574: // throw SQLError.createSQLException(
2575: // "No operations allowed after statement closed",
2576: // SQLError.SQL_STATE_GENERAL_ERROR);
2577: // }
2578: // } catch (SQLException sqlEx) {
2579: // checkAndFireConnectionError(sqlEx);
2580: // }
2581: //
2582: // return true;
2583: // }
2584: //
2585: // public boolean isPoolable() throws SQLException {
2586: // try {
2587: // if (this.wrappedStmt != null) {
2588: // return ((CallableStatement) this.wrappedStmt)
2589: // . isPoolable();
2590: // } else {
2591: // throw SQLError.createSQLException(
2592: // "No operations allowed after statement closed",
2593: // SQLError.SQL_STATE_GENERAL_ERROR);
2594: // }
2595: // } catch (SQLException sqlEx) {
2596: // checkAndFireConnectionError(sqlEx);
2597: // }
2598: //
2599: // return false;
2600: // }
2601: //
2602: // public void setPoolable(boolean poolable) throws SQLException {
2603: // try {
2604: // if (this.wrappedStmt != null) {
2605: // ((CallableStatement) this.wrappedStmt)
2606: // .setPoolable(poolable);
2607: // } else {
2608: // throw SQLError.createSQLException(
2609: // "No operations allowed after statement closed",
2610: // SQLError.SQL_STATE_GENERAL_ERROR);
2611: // }
2612: // } catch (SQLException sqlEx) {
2613: // checkAndFireConnectionError(sqlEx);
2614: // }
2615: //
2616: // }
2617: //
2618: // public boolean isWrapperFor(Class arg0) throws SQLException {
2619: // throw new NotYetImplementedException();
2620: // }
2621: //
2622: // public Object unwrap(Class arg0) throws SQLException {
2623: // throw new NotYetImplementedException();
2624: // }
2625:
2626: }
|