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