0001: /*
0002: * hgcommons 7
0003: * Hammurapi Group Common Library
0004: * Copyright (C) 2003 Hammurapi Group
0005: *
0006: * This program is free software; you can redistribute it and/or
0007: * modify it under the terms of the GNU Lesser General Public
0008: * License as published by the Free Software Foundation; either
0009: * version 2 of the License, or (at your option) any later version.
0010: *
0011: * This program is distributed in the hope that it will be useful,
0012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0014: * Lesser General Public License for more details.
0015: *
0016: * You should have received a copy of the GNU Lesser General Public
0017: * License along with this library; if not, write to the Free Software
0018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0019: *
0020: * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
0021: * e-Mail: support@hammurapi.biz
0022: */
0023: package biz.hammurapi.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:
0044: class ResultSetProxy implements ResultSet {
0045: private final SQLProcessor sqlProcessor;
0046: ResultSet master;
0047:
0048: ResultSetProxy(SQLProcessor processor, ResultSet master) {
0049: this .master = master;
0050: sqlProcessor = processor;
0051: }
0052:
0053: /**
0054: * @param row
0055: * @return
0056: * @throws java.sql.SQLException
0057: */
0058: public boolean absolute(int row) throws SQLException {
0059: return master.absolute(row);
0060: }
0061:
0062: /**
0063: * @throws java.sql.SQLException
0064: */
0065: public void afterLast() throws SQLException {
0066: master.afterLast();
0067: }
0068:
0069: /**
0070: * @throws java.sql.SQLException
0071: */
0072: public void beforeFirst() throws SQLException {
0073: master.beforeFirst();
0074: }
0075:
0076: /**
0077: * @throws java.sql.SQLException
0078: */
0079: public void cancelRowUpdates() throws SQLException {
0080: master.cancelRowUpdates();
0081: }
0082:
0083: /**
0084: * @throws java.sql.SQLException
0085: */
0086: public void clearWarnings() throws SQLException {
0087: master.clearWarnings();
0088: }
0089:
0090: /**
0091: * @throws java.sql.SQLException
0092: */
0093: public void close() throws SQLException {
0094: master.close();
0095: }
0096:
0097: /**
0098: * @throws java.sql.SQLException
0099: */
0100: public void deleteRow() throws SQLException {
0101: master.deleteRow();
0102: }
0103:
0104: /* (non-Javadoc)
0105: * @see java.lang.Object#equals(java.lang.Object)
0106: */
0107: public boolean equals(Object obj) {
0108: return master.equals(obj);
0109: }
0110:
0111: /**
0112: * @param columnName
0113: * @return
0114: * @throws java.sql.SQLException
0115: */
0116: public int findColumn(String columnName) throws SQLException {
0117: return master.findColumn(sqlProcessor.parse(columnName));
0118: }
0119:
0120: /**
0121: * @return
0122: * @throws java.sql.SQLException
0123: */
0124: public boolean first() throws SQLException {
0125: return master.first();
0126: }
0127:
0128: /**
0129: * @param i
0130: * @return
0131: * @throws java.sql.SQLException
0132: */
0133: public Array getArray(int i) throws SQLException {
0134: return master.getArray(i);
0135: }
0136:
0137: /**
0138: * @param colName
0139: * @return
0140: * @throws java.sql.SQLException
0141: */
0142: public Array getArray(String colName) throws SQLException {
0143: return master.getArray(sqlProcessor.parse(colName));
0144: }
0145:
0146: /**
0147: * @param columnIndex
0148: * @return
0149: * @throws java.sql.SQLException
0150: */
0151: public InputStream getAsciiStream(int columnIndex)
0152: throws SQLException {
0153: return master.getAsciiStream(columnIndex);
0154: }
0155:
0156: /**
0157: * @param columnName
0158: * @return
0159: * @throws java.sql.SQLException
0160: */
0161: public InputStream getAsciiStream(String columnName)
0162: throws SQLException {
0163: return master.getAsciiStream(sqlProcessor.parse(columnName));
0164: }
0165:
0166: /**
0167: * @param columnIndex
0168: * @return
0169: * @throws java.sql.SQLException
0170: */
0171: public BigDecimal getBigDecimal(int columnIndex)
0172: throws SQLException {
0173: return master.getBigDecimal(columnIndex);
0174: }
0175:
0176: /**
0177: * @param columnIndex
0178: * @param scale
0179: * @return
0180: * @throws java.sql.SQLException
0181: */
0182: public BigDecimal getBigDecimal(int columnIndex, int scale)
0183: throws SQLException {
0184: return master.getBigDecimal(columnIndex, scale);
0185: }
0186:
0187: /**
0188: * @param columnName
0189: * @return
0190: * @throws java.sql.SQLException
0191: */
0192: public BigDecimal getBigDecimal(String columnName)
0193: throws SQLException {
0194: return master.getBigDecimal(sqlProcessor.parse(columnName));
0195: }
0196:
0197: /**
0198: * @param columnName
0199: * @param scale
0200: * @return
0201: * @throws java.sql.SQLException
0202: */
0203: public BigDecimal getBigDecimal(String columnName, int scale)
0204: throws SQLException {
0205: return master.getBigDecimal(sqlProcessor.parse(columnName),
0206: scale);
0207: }
0208:
0209: /**
0210: * @param columnIndex
0211: * @return
0212: * @throws java.sql.SQLException
0213: */
0214: public InputStream getBinaryStream(int columnIndex)
0215: throws SQLException {
0216: return master.getBinaryStream(columnIndex);
0217: }
0218:
0219: /**
0220: * @param columnName
0221: * @return
0222: * @throws java.sql.SQLException
0223: */
0224: public InputStream getBinaryStream(String columnName)
0225: throws SQLException {
0226: return master.getBinaryStream(sqlProcessor.parse(columnName));
0227: }
0228:
0229: /**
0230: * @param i
0231: * @return
0232: * @throws java.sql.SQLException
0233: */
0234: public Blob getBlob(int i) throws SQLException {
0235: return master.getBlob(i);
0236: }
0237:
0238: /**
0239: * @param colName
0240: * @return
0241: * @throws java.sql.SQLException
0242: */
0243: public Blob getBlob(String colName) throws SQLException {
0244: return master.getBlob(sqlProcessor.parse(colName));
0245: }
0246:
0247: /**
0248: * @param columnIndex
0249: * @return
0250: * @throws java.sql.SQLException
0251: */
0252: public boolean getBoolean(int columnIndex) throws SQLException {
0253: return master.getBoolean(columnIndex);
0254: }
0255:
0256: /**
0257: * @param columnName
0258: * @return
0259: * @throws java.sql.SQLException
0260: */
0261: public boolean getBoolean(String columnName) throws SQLException {
0262: return master.getBoolean(sqlProcessor.parse(columnName));
0263: }
0264:
0265: /**
0266: * @param columnIndex
0267: * @return
0268: * @throws java.sql.SQLException
0269: */
0270: public byte getByte(int columnIndex) throws SQLException {
0271: return master.getByte(columnIndex);
0272: }
0273:
0274: /**
0275: * @param columnName
0276: * @return
0277: * @throws java.sql.SQLException
0278: */
0279: public byte getByte(String columnName) throws SQLException {
0280: return master.getByte(sqlProcessor.parse(columnName));
0281: }
0282:
0283: /**
0284: * @param columnIndex
0285: * @return
0286: * @throws java.sql.SQLException
0287: */
0288: public byte[] getBytes(int columnIndex) throws SQLException {
0289: return master.getBytes(columnIndex);
0290: }
0291:
0292: /**
0293: * @param columnName
0294: * @return
0295: * @throws java.sql.SQLException
0296: */
0297: public byte[] getBytes(String columnName) throws SQLException {
0298: return master.getBytes(sqlProcessor.parse(columnName));
0299: }
0300:
0301: /**
0302: * @param columnIndex
0303: * @return
0304: * @throws java.sql.SQLException
0305: */
0306: public Reader getCharacterStream(int columnIndex)
0307: throws SQLException {
0308: return master.getCharacterStream(columnIndex);
0309: }
0310:
0311: /**
0312: * @param columnName
0313: * @return
0314: * @throws java.sql.SQLException
0315: */
0316: public Reader getCharacterStream(String columnName)
0317: throws SQLException {
0318: return master
0319: .getCharacterStream(sqlProcessor.parse(columnName));
0320: }
0321:
0322: /**
0323: * @param i
0324: * @return
0325: * @throws java.sql.SQLException
0326: */
0327: public Clob getClob(int i) throws SQLException {
0328: return master.getClob(i);
0329: }
0330:
0331: /**
0332: * @param colName
0333: * @return
0334: * @throws java.sql.SQLException
0335: */
0336: public Clob getClob(String colName) throws SQLException {
0337: return master.getClob(sqlProcessor.parse(colName));
0338: }
0339:
0340: /**
0341: * @return
0342: * @throws java.sql.SQLException
0343: */
0344: public int getConcurrency() throws SQLException {
0345: return master.getConcurrency();
0346: }
0347:
0348: /**
0349: * @return
0350: * @throws java.sql.SQLException
0351: */
0352: public String getCursorName() throws SQLException {
0353: return master.getCursorName();
0354: }
0355:
0356: /**
0357: * @param columnIndex
0358: * @return
0359: * @throws java.sql.SQLException
0360: */
0361: public Date getDate(int columnIndex) throws SQLException {
0362: return master.getDate(columnIndex);
0363: }
0364:
0365: /**
0366: * @param columnIndex
0367: * @param cal
0368: * @return
0369: * @throws java.sql.SQLException
0370: */
0371: public Date getDate(int columnIndex, Calendar cal)
0372: throws SQLException {
0373: return master.getDate(columnIndex, cal);
0374: }
0375:
0376: /**
0377: * @param columnName
0378: * @return
0379: * @throws java.sql.SQLException
0380: */
0381: public Date getDate(String columnName) throws SQLException {
0382: return master.getDate(sqlProcessor.parse(columnName));
0383: }
0384:
0385: /**
0386: * @param columnName
0387: * @param cal
0388: * @return
0389: * @throws java.sql.SQLException
0390: */
0391: public Date getDate(String columnName, Calendar cal)
0392: throws SQLException {
0393: return master.getDate(sqlProcessor.parse(columnName), cal);
0394: }
0395:
0396: /**
0397: * @param columnIndex
0398: * @return
0399: * @throws java.sql.SQLException
0400: */
0401: public double getDouble(int columnIndex) throws SQLException {
0402: return master.getDouble(columnIndex);
0403: }
0404:
0405: /**
0406: * @param columnName
0407: * @return
0408: * @throws java.sql.SQLException
0409: */
0410: public double getDouble(String columnName) throws SQLException {
0411: return master.getDouble(sqlProcessor.parse(columnName));
0412: }
0413:
0414: /**
0415: * @return
0416: * @throws java.sql.SQLException
0417: */
0418: public int getFetchDirection() throws SQLException {
0419: return master.getFetchDirection();
0420: }
0421:
0422: /**
0423: * @return
0424: * @throws java.sql.SQLException
0425: */
0426: public int getFetchSize() throws SQLException {
0427: return master.getFetchSize();
0428: }
0429:
0430: /**
0431: * @param columnIndex
0432: * @return
0433: * @throws java.sql.SQLException
0434: */
0435: public float getFloat(int columnIndex) throws SQLException {
0436: return master.getFloat(columnIndex);
0437: }
0438:
0439: /**
0440: * @param columnName
0441: * @return
0442: * @throws java.sql.SQLException
0443: */
0444: public float getFloat(String columnName) throws SQLException {
0445: return master.getFloat(sqlProcessor.parse(columnName));
0446: }
0447:
0448: /**
0449: * @param columnIndex
0450: * @return
0451: * @throws java.sql.SQLException
0452: */
0453: public int getInt(int columnIndex) throws SQLException {
0454: return master.getInt(columnIndex);
0455: }
0456:
0457: /**
0458: * @param columnName
0459: * @return
0460: * @throws java.sql.SQLException
0461: */
0462: public int getInt(String columnName) throws SQLException {
0463: return master.getInt(sqlProcessor.parse(columnName));
0464: }
0465:
0466: /**
0467: * @param columnIndex
0468: * @return
0469: * @throws java.sql.SQLException
0470: */
0471: public long getLong(int columnIndex) throws SQLException {
0472: return master.getLong(columnIndex);
0473: }
0474:
0475: /**
0476: * @param columnName
0477: * @return
0478: * @throws java.sql.SQLException
0479: */
0480: public long getLong(String columnName) throws SQLException {
0481: return master.getLong(sqlProcessor.parse(columnName));
0482: }
0483:
0484: /**
0485: * @return
0486: * @throws java.sql.SQLException
0487: */
0488: public ResultSetMetaData getMetaData() throws SQLException {
0489: return master.getMetaData();
0490: }
0491:
0492: /**
0493: * @param columnIndex
0494: * @return
0495: * @throws java.sql.SQLException
0496: */
0497: public Object getObject(int columnIndex) throws SQLException {
0498: return master.getObject(columnIndex);
0499: }
0500:
0501: /**
0502: * @param i
0503: * @param map
0504: * @return
0505: * @throws java.sql.SQLException
0506: */
0507: public Object getObject(int i, Map map) throws SQLException {
0508: return master.getObject(i, map);
0509: }
0510:
0511: /**
0512: * @param columnName
0513: * @return
0514: * @throws java.sql.SQLException
0515: */
0516: public Object getObject(String columnName) throws SQLException {
0517: return master.getObject(sqlProcessor.parse(columnName));
0518: }
0519:
0520: /**
0521: * @param colName
0522: * @param map
0523: * @return
0524: * @throws java.sql.SQLException
0525: */
0526: public Object getObject(String colName, Map map)
0527: throws SQLException {
0528: return master.getObject(sqlProcessor.parse(colName), map);
0529: }
0530:
0531: /**
0532: * @param i
0533: * @return
0534: * @throws java.sql.SQLException
0535: */
0536: public Ref getRef(int i) throws SQLException {
0537: return master.getRef(i);
0538: }
0539:
0540: /**
0541: * @param colName
0542: * @return
0543: * @throws java.sql.SQLException
0544: */
0545: public Ref getRef(String colName) throws SQLException {
0546: return master.getRef(sqlProcessor.parse(colName));
0547: }
0548:
0549: /**
0550: * @return
0551: * @throws java.sql.SQLException
0552: */
0553: public int getRow() throws SQLException {
0554: return master.getRow();
0555: }
0556:
0557: /**
0558: * @param columnIndex
0559: * @return
0560: * @throws java.sql.SQLException
0561: */
0562: public short getShort(int columnIndex) throws SQLException {
0563: return master.getShort(columnIndex);
0564: }
0565:
0566: /**
0567: * @param columnName
0568: * @return
0569: * @throws java.sql.SQLException
0570: */
0571: public short getShort(String columnName) throws SQLException {
0572: return master.getShort(sqlProcessor.parse(columnName));
0573: }
0574:
0575: /**
0576: * @return
0577: * @throws java.sql.SQLException
0578: */
0579: public Statement getStatement() throws SQLException {
0580: return master.getStatement();
0581: }
0582:
0583: /**
0584: * @param columnIndex
0585: * @return
0586: * @throws java.sql.SQLException
0587: */
0588: public String getString(int columnIndex) throws SQLException {
0589: return master.getString(columnIndex);
0590: }
0591:
0592: /**
0593: * @param columnName
0594: * @return
0595: * @throws java.sql.SQLException
0596: */
0597: public String getString(String columnName) throws SQLException {
0598: return master.getString(sqlProcessor.parse(columnName));
0599: }
0600:
0601: /**
0602: * @param columnIndex
0603: * @return
0604: * @throws java.sql.SQLException
0605: */
0606: public Time getTime(int columnIndex) throws SQLException {
0607: return master.getTime(columnIndex);
0608: }
0609:
0610: /**
0611: * @param columnIndex
0612: * @param cal
0613: * @return
0614: * @throws java.sql.SQLException
0615: */
0616: public Time getTime(int columnIndex, Calendar cal)
0617: throws SQLException {
0618: return master.getTime(columnIndex, cal);
0619: }
0620:
0621: /**
0622: * @param columnName
0623: * @return
0624: * @throws java.sql.SQLException
0625: */
0626: public Time getTime(String columnName) throws SQLException {
0627: return master.getTime(sqlProcessor.parse(columnName));
0628: }
0629:
0630: /**
0631: * @param columnName
0632: * @param cal
0633: * @return
0634: * @throws java.sql.SQLException
0635: */
0636: public Time getTime(String columnName, Calendar cal)
0637: throws SQLException {
0638: return master.getTime(sqlProcessor.parse(columnName), cal);
0639: }
0640:
0641: /**
0642: * @param columnIndex
0643: * @return
0644: * @throws java.sql.SQLException
0645: */
0646: public Timestamp getTimestamp(int columnIndex) throws SQLException {
0647: return master.getTimestamp(columnIndex);
0648: }
0649:
0650: /**
0651: * @param columnIndex
0652: * @param cal
0653: * @return
0654: * @throws java.sql.SQLException
0655: */
0656: public Timestamp getTimestamp(int columnIndex, Calendar cal)
0657: throws SQLException {
0658: return master.getTimestamp(columnIndex, cal);
0659: }
0660:
0661: /**
0662: * @param columnName
0663: * @return
0664: * @throws java.sql.SQLException
0665: */
0666: public Timestamp getTimestamp(String columnName)
0667: throws SQLException {
0668: return master.getTimestamp(sqlProcessor.parse(columnName));
0669: }
0670:
0671: /**
0672: * @param columnName
0673: * @param cal
0674: * @return
0675: * @throws java.sql.SQLException
0676: */
0677: public Timestamp getTimestamp(String columnName, Calendar cal)
0678: throws SQLException {
0679: return master.getTimestamp(sqlProcessor.parse(columnName), cal);
0680: }
0681:
0682: /**
0683: * @return
0684: * @throws java.sql.SQLException
0685: */
0686: public int getType() throws SQLException {
0687: return master.getType();
0688: }
0689:
0690: /**
0691: * @param columnIndex
0692: * @return
0693: * @throws java.sql.SQLException
0694: */
0695: public InputStream getUnicodeStream(int columnIndex)
0696: throws SQLException {
0697: return master.getUnicodeStream(columnIndex);
0698: }
0699:
0700: /**
0701: * @param columnName
0702: * @return
0703: * @throws java.sql.SQLException
0704: */
0705: public InputStream getUnicodeStream(String columnName)
0706: throws SQLException {
0707: return master.getUnicodeStream(sqlProcessor.parse(columnName));
0708: }
0709:
0710: /**
0711: * @param columnIndex
0712: * @return
0713: * @throws java.sql.SQLException
0714: */
0715: public URL getURL(int columnIndex) throws SQLException {
0716: return master.getURL(columnIndex);
0717: }
0718:
0719: /**
0720: * @param columnName
0721: * @return
0722: * @throws java.sql.SQLException
0723: */
0724: public URL getURL(String columnName) throws SQLException {
0725: return master.getURL(sqlProcessor.parse(columnName));
0726: }
0727:
0728: /**
0729: * @return
0730: * @throws java.sql.SQLException
0731: */
0732: public SQLWarning getWarnings() throws SQLException {
0733: return master.getWarnings();
0734: }
0735:
0736: /* (non-Javadoc)
0737: * @see java.lang.Object#hashCode()
0738: */
0739: public int hashCode() {
0740: return master.hashCode();
0741: }
0742:
0743: /**
0744: * @throws java.sql.SQLException
0745: */
0746: public void insertRow() throws SQLException {
0747: master.insertRow();
0748: }
0749:
0750: /**
0751: * @return
0752: * @throws java.sql.SQLException
0753: */
0754: public boolean isAfterLast() throws SQLException {
0755: return master.isAfterLast();
0756: }
0757:
0758: /**
0759: * @return
0760: * @throws java.sql.SQLException
0761: */
0762: public boolean isBeforeFirst() throws SQLException {
0763: return master.isBeforeFirst();
0764: }
0765:
0766: /**
0767: * @return
0768: * @throws java.sql.SQLException
0769: */
0770: public boolean isFirst() throws SQLException {
0771: return master.isFirst();
0772: }
0773:
0774: /**
0775: * @return
0776: * @throws java.sql.SQLException
0777: */
0778: public boolean isLast() throws SQLException {
0779: return master.isLast();
0780: }
0781:
0782: /**
0783: * @return
0784: * @throws java.sql.SQLException
0785: */
0786: public boolean last() throws SQLException {
0787: return master.last();
0788: }
0789:
0790: /**
0791: * @throws java.sql.SQLException
0792: */
0793: public void moveToCurrentRow() throws SQLException {
0794: master.moveToCurrentRow();
0795: }
0796:
0797: /**
0798: * @throws java.sql.SQLException
0799: */
0800: public void moveToInsertRow() throws SQLException {
0801: master.moveToInsertRow();
0802: }
0803:
0804: /**
0805: * @return
0806: * @throws java.sql.SQLException
0807: */
0808: public boolean next() throws SQLException {
0809: return master.next();
0810: }
0811:
0812: /**
0813: * @return
0814: * @throws java.sql.SQLException
0815: */
0816: public boolean previous() throws SQLException {
0817: return master.previous();
0818: }
0819:
0820: /**
0821: * @throws java.sql.SQLException
0822: */
0823: public void refreshRow() throws SQLException {
0824: master.refreshRow();
0825: }
0826:
0827: /**
0828: * @param rows
0829: * @return
0830: * @throws java.sql.SQLException
0831: */
0832: public boolean relative(int rows) throws SQLException {
0833: return master.relative(rows);
0834: }
0835:
0836: /**
0837: * @return
0838: * @throws java.sql.SQLException
0839: */
0840: public boolean rowDeleted() throws SQLException {
0841: return master.rowDeleted();
0842: }
0843:
0844: /**
0845: * @return
0846: * @throws java.sql.SQLException
0847: */
0848: public boolean rowInserted() throws SQLException {
0849: return master.rowInserted();
0850: }
0851:
0852: /**
0853: * @return
0854: * @throws java.sql.SQLException
0855: */
0856: public boolean rowUpdated() throws SQLException {
0857: return master.rowUpdated();
0858: }
0859:
0860: /**
0861: * @param direction
0862: * @throws java.sql.SQLException
0863: */
0864: public void setFetchDirection(int direction) throws SQLException {
0865: master.setFetchDirection(direction);
0866: }
0867:
0868: /**
0869: * @param rows
0870: * @throws java.sql.SQLException
0871: */
0872: public void setFetchSize(int rows) throws SQLException {
0873: master.setFetchSize(rows);
0874: }
0875:
0876: /* (non-Javadoc)
0877: * @see java.lang.Object#toString()
0878: */
0879: public String toString() {
0880: return master.toString();
0881: }
0882:
0883: /**
0884: * @param columnIndex
0885: * @param x
0886: * @throws java.sql.SQLException
0887: */
0888: public void updateArray(int columnIndex, Array x)
0889: throws SQLException {
0890: master.updateArray(columnIndex, x);
0891: }
0892:
0893: /**
0894: * @param columnName
0895: * @param x
0896: * @throws java.sql.SQLException
0897: */
0898: public void updateArray(String columnName, Array x)
0899: throws SQLException {
0900: master.updateArray(sqlProcessor.parse(columnName), x);
0901: }
0902:
0903: /**
0904: * @param columnIndex
0905: * @param x
0906: * @param length
0907: * @throws java.sql.SQLException
0908: */
0909: public void updateAsciiStream(int columnIndex, InputStream x,
0910: int length) throws SQLException {
0911: master.updateAsciiStream(columnIndex, x, length);
0912: }
0913:
0914: /**
0915: * @param columnName
0916: * @param x
0917: * @param length
0918: * @throws java.sql.SQLException
0919: */
0920: public void updateAsciiStream(String columnName, InputStream x,
0921: int length) throws SQLException {
0922: master.updateAsciiStream(sqlProcessor.parse(columnName), x,
0923: length);
0924: }
0925:
0926: /**
0927: * @param columnIndex
0928: * @param x
0929: * @throws java.sql.SQLException
0930: */
0931: public void updateBigDecimal(int columnIndex, BigDecimal x)
0932: throws SQLException {
0933: master.updateBigDecimal(columnIndex, x);
0934: }
0935:
0936: /**
0937: * @param columnName
0938: * @param x
0939: * @throws java.sql.SQLException
0940: */
0941: public void updateBigDecimal(String columnName, BigDecimal x)
0942: throws SQLException {
0943: master.updateBigDecimal(sqlProcessor.parse(columnName), x);
0944: }
0945:
0946: /**
0947: * @param columnIndex
0948: * @param x
0949: * @param length
0950: * @throws java.sql.SQLException
0951: */
0952: public void updateBinaryStream(int columnIndex, InputStream x,
0953: int length) throws SQLException {
0954: master.updateBinaryStream(columnIndex, x, length);
0955: }
0956:
0957: /**
0958: * @param columnName
0959: * @param x
0960: * @param length
0961: * @throws java.sql.SQLException
0962: */
0963: public void updateBinaryStream(String columnName, InputStream x,
0964: int length) throws SQLException {
0965: master.updateBinaryStream(sqlProcessor.parse(columnName), x,
0966: length);
0967: }
0968:
0969: /**
0970: * @param columnIndex
0971: * @param x
0972: * @throws java.sql.SQLException
0973: */
0974: public void updateBlob(int columnIndex, Blob x) throws SQLException {
0975: master.updateBlob(columnIndex, x);
0976: }
0977:
0978: /**
0979: * @param columnName
0980: * @param x
0981: * @throws java.sql.SQLException
0982: */
0983: public void updateBlob(String columnName, Blob x)
0984: throws SQLException {
0985: master.updateBlob(sqlProcessor.parse(columnName), x);
0986: }
0987:
0988: /**
0989: * @param columnIndex
0990: * @param x
0991: * @throws java.sql.SQLException
0992: */
0993: public void updateBoolean(int columnIndex, boolean x)
0994: throws SQLException {
0995: master.updateBoolean(columnIndex, x);
0996: }
0997:
0998: /**
0999: * @param columnName
1000: * @param x
1001: * @throws java.sql.SQLException
1002: */
1003: public void updateBoolean(String columnName, boolean x)
1004: throws SQLException {
1005: master.updateBoolean(sqlProcessor.parse(columnName), x);
1006: }
1007:
1008: /**
1009: * @param columnIndex
1010: * @param x
1011: * @throws java.sql.SQLException
1012: */
1013: public void updateByte(int columnIndex, byte x) throws SQLException {
1014: master.updateByte(columnIndex, x);
1015: }
1016:
1017: /**
1018: * @param columnName
1019: * @param x
1020: * @throws java.sql.SQLException
1021: */
1022: public void updateByte(String columnName, byte x)
1023: throws SQLException {
1024: master.updateByte(sqlProcessor.parse(columnName), x);
1025: }
1026:
1027: /**
1028: * @param columnIndex
1029: * @param x
1030: * @throws java.sql.SQLException
1031: */
1032: public void updateBytes(int columnIndex, byte[] x)
1033: throws SQLException {
1034: master.updateBytes(columnIndex, x);
1035: }
1036:
1037: /**
1038: * @param columnName
1039: * @param x
1040: * @throws java.sql.SQLException
1041: */
1042: public void updateBytes(String columnName, byte[] x)
1043: throws SQLException {
1044: master.updateBytes(sqlProcessor.parse(columnName), x);
1045: }
1046:
1047: /**
1048: * @param columnIndex
1049: * @param x
1050: * @param length
1051: * @throws java.sql.SQLException
1052: */
1053: public void updateCharacterStream(int columnIndex, Reader x,
1054: int length) throws SQLException {
1055: master.updateCharacterStream(columnIndex, x, length);
1056: }
1057:
1058: /**
1059: * @param columnName
1060: * @param reader
1061: * @param length
1062: * @throws java.sql.SQLException
1063: */
1064: public void updateCharacterStream(String columnName, Reader reader,
1065: int length) throws SQLException {
1066: master.updateCharacterStream(sqlProcessor.parse(columnName),
1067: reader, length);
1068: }
1069:
1070: /**
1071: * @param columnIndex
1072: * @param x
1073: * @throws java.sql.SQLException
1074: */
1075: public void updateClob(int columnIndex, Clob x) throws SQLException {
1076: master.updateClob(columnIndex, x);
1077: }
1078:
1079: /**
1080: * @param columnName
1081: * @param x
1082: * @throws java.sql.SQLException
1083: */
1084: public void updateClob(String columnName, Clob x)
1085: throws SQLException {
1086: master.updateClob(sqlProcessor.parse(columnName), x);
1087: }
1088:
1089: /**
1090: * @param columnIndex
1091: * @param x
1092: * @throws java.sql.SQLException
1093: */
1094: public void updateDate(int columnIndex, Date x) throws SQLException {
1095: master.updateDate(columnIndex, x);
1096: }
1097:
1098: /**
1099: * @param columnName
1100: * @param x
1101: * @throws java.sql.SQLException
1102: */
1103: public void updateDate(String columnName, Date x)
1104: throws SQLException {
1105: master.updateDate(sqlProcessor.parse(columnName), x);
1106: }
1107:
1108: /**
1109: * @param columnIndex
1110: * @param x
1111: * @throws java.sql.SQLException
1112: */
1113: public void updateDouble(int columnIndex, double x)
1114: throws SQLException {
1115: master.updateDouble(columnIndex, x);
1116: }
1117:
1118: /**
1119: * @param columnName
1120: * @param x
1121: * @throws java.sql.SQLException
1122: */
1123: public void updateDouble(String columnName, double x)
1124: throws SQLException {
1125: master.updateDouble(sqlProcessor.parse(columnName), x);
1126: }
1127:
1128: /**
1129: * @param columnIndex
1130: * @param x
1131: * @throws java.sql.SQLException
1132: */
1133: public void updateFloat(int columnIndex, float x)
1134: throws SQLException {
1135: master.updateFloat(columnIndex, x);
1136: }
1137:
1138: /**
1139: * @param columnName
1140: * @param x
1141: * @throws java.sql.SQLException
1142: */
1143: public void updateFloat(String columnName, float x)
1144: throws SQLException {
1145: master.updateFloat(sqlProcessor.parse(columnName), x);
1146: }
1147:
1148: /**
1149: * @param columnIndex
1150: * @param x
1151: * @throws java.sql.SQLException
1152: */
1153: public void updateInt(int columnIndex, int x) throws SQLException {
1154: master.updateInt(columnIndex, x);
1155: }
1156:
1157: /**
1158: * @param columnName
1159: * @param x
1160: * @throws java.sql.SQLException
1161: */
1162: public void updateInt(String columnName, int x) throws SQLException {
1163: master.updateInt(sqlProcessor.parse(columnName), x);
1164: }
1165:
1166: /**
1167: * @param columnIndex
1168: * @param x
1169: * @throws java.sql.SQLException
1170: */
1171: public void updateLong(int columnIndex, long x) throws SQLException {
1172: master.updateLong(columnIndex, x);
1173: }
1174:
1175: /**
1176: * @param columnName
1177: * @param x
1178: * @throws java.sql.SQLException
1179: */
1180: public void updateLong(String columnName, long x)
1181: throws SQLException {
1182: master.updateLong(sqlProcessor.parse(columnName), x);
1183: }
1184:
1185: /**
1186: * @param columnIndex
1187: * @throws java.sql.SQLException
1188: */
1189: public void updateNull(int columnIndex) throws SQLException {
1190: master.updateNull(columnIndex);
1191: }
1192:
1193: /**
1194: * @param columnName
1195: * @throws java.sql.SQLException
1196: */
1197: public void updateNull(String columnName) throws SQLException {
1198: master.updateNull(sqlProcessor.parse(columnName));
1199: }
1200:
1201: /**
1202: * @param columnIndex
1203: * @param x
1204: * @throws java.sql.SQLException
1205: */
1206: public void updateObject(int columnIndex, Object x)
1207: throws SQLException {
1208: master.updateObject(columnIndex, x);
1209: }
1210:
1211: /**
1212: * @param columnIndex
1213: * @param x
1214: * @param scale
1215: * @throws java.sql.SQLException
1216: */
1217: public void updateObject(int columnIndex, Object x, int scale)
1218: throws SQLException {
1219: master.updateObject(columnIndex, x, scale);
1220: }
1221:
1222: /**
1223: * @param columnName
1224: * @param x
1225: * @throws java.sql.SQLException
1226: */
1227: public void updateObject(String columnName, Object x)
1228: throws SQLException {
1229: master.updateObject(sqlProcessor.parse(columnName), x);
1230: }
1231:
1232: /**
1233: * @param columnName
1234: * @param x
1235: * @param scale
1236: * @throws java.sql.SQLException
1237: */
1238: public void updateObject(String columnName, Object x, int scale)
1239: throws SQLException {
1240: master.updateObject(sqlProcessor.parse(columnName), x, scale);
1241: }
1242:
1243: /**
1244: * @param columnIndex
1245: * @param x
1246: * @throws java.sql.SQLException
1247: */
1248: public void updateRef(int columnIndex, Ref x) throws SQLException {
1249: master.updateRef(columnIndex, x);
1250: }
1251:
1252: /**
1253: * @param columnName
1254: * @param x
1255: * @throws java.sql.SQLException
1256: */
1257: public void updateRef(String columnName, Ref x) throws SQLException {
1258: master.updateRef(sqlProcessor.parse(columnName), x);
1259: }
1260:
1261: /**
1262: * @throws java.sql.SQLException
1263: */
1264: public void updateRow() throws SQLException {
1265: master.updateRow();
1266: }
1267:
1268: /**
1269: * @param columnIndex
1270: * @param x
1271: * @throws java.sql.SQLException
1272: */
1273: public void updateShort(int columnIndex, short x)
1274: throws SQLException {
1275: master.updateShort(columnIndex, x);
1276: }
1277:
1278: /**
1279: * @param columnName
1280: * @param x
1281: * @throws java.sql.SQLException
1282: */
1283: public void updateShort(String columnName, short x)
1284: throws SQLException {
1285: master.updateShort(sqlProcessor.parse(columnName), x);
1286: }
1287:
1288: /**
1289: * @param columnIndex
1290: * @param x
1291: * @throws java.sql.SQLException
1292: */
1293: public void updateString(int columnIndex, String x)
1294: throws SQLException {
1295: master.updateString(columnIndex, x);
1296: }
1297:
1298: /**
1299: * @param columnName
1300: * @param x
1301: * @throws java.sql.SQLException
1302: */
1303: public void updateString(String columnName, String x)
1304: throws SQLException {
1305: master.updateString(sqlProcessor.parse(columnName), x);
1306: }
1307:
1308: /**
1309: * @param columnIndex
1310: * @param x
1311: * @throws java.sql.SQLException
1312: */
1313: public void updateTime(int columnIndex, Time x) throws SQLException {
1314: master.updateTime(columnIndex, x);
1315: }
1316:
1317: /**
1318: * @param columnName
1319: * @param x
1320: * @throws java.sql.SQLException
1321: */
1322: public void updateTime(String columnName, Time x)
1323: throws SQLException {
1324: master.updateTime(sqlProcessor.parse(columnName), x);
1325: }
1326:
1327: /**
1328: * @param columnIndex
1329: * @param x
1330: * @throws java.sql.SQLException
1331: */
1332: public void updateTimestamp(int columnIndex, Timestamp x)
1333: throws SQLException {
1334: master.updateTimestamp(columnIndex, x);
1335: }
1336:
1337: /**
1338: * @param columnName
1339: * @param x
1340: * @throws java.sql.SQLException
1341: */
1342: public void updateTimestamp(String columnName, Timestamp x)
1343: throws SQLException {
1344: master.updateTimestamp(sqlProcessor.parse(columnName), x);
1345: }
1346:
1347: /**
1348: * @return
1349: * @throws java.sql.SQLException
1350: */
1351: public boolean wasNull() throws SQLException {
1352: return master.wasNull();
1353: }
1354: }
|