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