0001: package com.mockrunner.mock.jdbc;
0002:
0003: import java.io.InputStream;
0004: import java.io.Reader;
0005: import java.math.BigDecimal;
0006: import java.net.URL;
0007: import java.sql.Array;
0008: import java.sql.Blob;
0009: import java.sql.Clob;
0010: import java.sql.Date; //import java.sql.NClob;
0011: import java.sql.Ref;
0012: import java.sql.ResultSet;
0013: import java.sql.ResultSetMetaData; //import java.sql.RowId;
0014: import java.sql.SQLException;
0015: import java.sql.SQLWarning; //import java.sql.SQLXML;
0016: import java.sql.Statement;
0017: import java.sql.Time;
0018: import java.sql.Timestamp;
0019: import java.util.Calendar;
0020: import java.util.Collections;
0021: import java.util.List;
0022: import java.util.Map;
0023:
0024: /**
0025: * Contains a list of <code>ResultSet</code> objects where the <code>next()</code>
0026: * method iterates through all <code>ResultSet</code> objects in the list.
0027: * The get-methods and <code>next()</code> can be used. All update-methods
0028: * and scroll-methods throw an <code>SQLException</code>.
0029: */
0030: public class PolyResultSet implements ResultSet {
0031: private List resultSets;
0032: private int position;
0033: private ResultSet current;
0034:
0035: public PolyResultSet(List resultSets) {
0036: this .resultSets = resultSets;
0037: }
0038:
0039: public List getUnderlyingResultSetList() {
0040: return Collections.unmodifiableList(resultSets);
0041: }
0042:
0043: public boolean next() throws SQLException {
0044: if ((current != null) && current.next()) {
0045: return true;
0046: } else {
0047: while (position < resultSets.size()) {
0048: current = (ResultSet) resultSets.get(position++);
0049: if (current.next())
0050: return true;
0051: }
0052: }
0053: return false;
0054: }
0055:
0056: /**
0057: * Does nothing.
0058: */
0059: public void close() throws SQLException {
0060:
0061: }
0062:
0063: public boolean isClosed() throws SQLException {
0064: return false;
0065: }
0066:
0067: public boolean wasNull() throws SQLException {
0068: return current.wasNull();
0069: }
0070:
0071: public String getString(int columnIndex) throws SQLException {
0072: return current.getString(columnIndex);
0073: }
0074:
0075: /*public String getNString(int columnIndex) throws SQLException
0076: {
0077: return current.getNString(columnIndex);
0078: }*/
0079:
0080: public boolean getBoolean(int columnIndex) throws SQLException {
0081: return current.getBoolean(columnIndex);
0082: }
0083:
0084: public byte getByte(int columnIndex) throws SQLException {
0085: return current.getByte(columnIndex);
0086: }
0087:
0088: public short getShort(int columnIndex) throws SQLException {
0089: return current.getShort(columnIndex);
0090: }
0091:
0092: public int getInt(int columnIndex) throws SQLException {
0093: return current.getInt(columnIndex);
0094: }
0095:
0096: public long getLong(int columnIndex) throws SQLException {
0097: return current.getLong(columnIndex);
0098: }
0099:
0100: public float getFloat(int columnIndex) throws SQLException {
0101: return current.getFloat(columnIndex);
0102: }
0103:
0104: public double getDouble(int columnIndex) throws SQLException {
0105: return current.getDouble(columnIndex);
0106: }
0107:
0108: public BigDecimal getBigDecimal(int columnIndex, int scale)
0109: throws SQLException {
0110: return current.getBigDecimal(columnIndex);
0111: }
0112:
0113: public BigDecimal getBigDecimal(int columnIndex)
0114: throws SQLException {
0115: return current.getBigDecimal(columnIndex);
0116: }
0117:
0118: public byte[] getBytes(int columnIndex) throws SQLException {
0119: return current.getBytes(columnIndex);
0120: }
0121:
0122: public Date getDate(int columnIndex) throws SQLException {
0123: return current.getDate(columnIndex);
0124: }
0125:
0126: public Date getDate(int columnIndex, Calendar cal)
0127: throws SQLException {
0128: return current.getDate(columnIndex, cal);
0129: }
0130:
0131: public Time getTime(int columnIndex) throws SQLException {
0132: return current.getTime(columnIndex);
0133: }
0134:
0135: public Time getTime(int columnIndex, Calendar cal)
0136: throws SQLException {
0137: return current.getTime(columnIndex, cal);
0138: }
0139:
0140: public Timestamp getTimestamp(int columnIndex) throws SQLException {
0141: return current.getTimestamp(columnIndex);
0142: }
0143:
0144: public Timestamp getTimestamp(int columnIndex, Calendar cal)
0145: throws SQLException {
0146: return current.getTimestamp(columnIndex, cal);
0147: }
0148:
0149: public InputStream getAsciiStream(int columnIndex)
0150: throws SQLException {
0151: return current.getAsciiStream(columnIndex);
0152: }
0153:
0154: public InputStream getBinaryStream(int columnIndex)
0155: throws SQLException {
0156: return current.getBinaryStream(columnIndex);
0157: }
0158:
0159: public InputStream getUnicodeStream(int columnIndex)
0160: throws SQLException {
0161: return current.getUnicodeStream(columnIndex);
0162: }
0163:
0164: public Reader getCharacterStream(int columnIndex)
0165: throws SQLException {
0166: return current.getCharacterStream(columnIndex);
0167: }
0168:
0169: public Reader getNCharacterStream(int columnIndex)
0170: throws SQLException {
0171: return current.getCharacterStream(columnIndex);
0172: }
0173:
0174: public Ref getRef(int columnIndex) throws SQLException {
0175: return current.getRef(columnIndex);
0176: }
0177:
0178: /*public RowId getRowId(int columnIndex) throws SQLException
0179: {
0180: return current.getRowId(columnIndex);
0181: }*/
0182:
0183: public Blob getBlob(int columnIndex) throws SQLException {
0184: return current.getBlob(columnIndex);
0185: }
0186:
0187: public Clob getClob(int columnIndex) throws SQLException {
0188: return current.getClob(columnIndex);
0189: }
0190:
0191: /*public NClob getNClob(int columnIndex) throws SQLException
0192: {
0193: return current.getNClob(columnIndex);
0194: }*/
0195:
0196: /*public SQLXML getSQLXML(int columnIndex) throws SQLException
0197: {
0198: return current.getSQLXML(columnIndex);
0199: }*/
0200:
0201: public Array getArray(int columnIndex) throws SQLException {
0202: return current.getArray(columnIndex);
0203: }
0204:
0205: public URL getURL(int columnIndex) throws SQLException {
0206: return current.getURL(columnIndex);
0207: }
0208:
0209: public Object getObject(int columnIndex) throws SQLException {
0210: return current.getObject(columnIndex);
0211: }
0212:
0213: public Object getObject(int columnIndex, Map map)
0214: throws SQLException {
0215: return current.getObject(columnIndex, map);
0216: }
0217:
0218: public String getString(String columnName) throws SQLException {
0219: return current.getString(columnName);
0220: }
0221:
0222: public String getNString(String columnName) throws SQLException {
0223: return current.getString(columnName);
0224: }
0225:
0226: public boolean getBoolean(String columnName) throws SQLException {
0227: return current.getBoolean(columnName);
0228: }
0229:
0230: public byte getByte(String columnName) throws SQLException {
0231: return current.getByte(columnName);
0232: }
0233:
0234: public short getShort(String columnName) throws SQLException {
0235: return current.getShort(columnName);
0236: }
0237:
0238: public int getInt(String columnName) throws SQLException {
0239: return current.getInt(columnName);
0240: }
0241:
0242: public long getLong(String columnName) throws SQLException {
0243: return current.getLong(columnName);
0244: }
0245:
0246: public float getFloat(String columnName) throws SQLException {
0247: return current.getFloat(columnName);
0248: }
0249:
0250: public double getDouble(String columnName) throws SQLException {
0251: return current.getDouble(columnName);
0252: }
0253:
0254: public BigDecimal getBigDecimal(String columnName, int scale)
0255: throws SQLException {
0256: return current.getBigDecimal(columnName);
0257: }
0258:
0259: public BigDecimal getBigDecimal(String columnName)
0260: throws SQLException {
0261: return current.getBigDecimal(columnName);
0262: }
0263:
0264: public byte[] getBytes(String columnName) throws SQLException {
0265: return current.getBytes(columnName);
0266: }
0267:
0268: public Date getDate(String columnName) throws SQLException {
0269: return current.getDate(columnName);
0270: }
0271:
0272: public Date getDate(String columnName, Calendar cal)
0273: throws SQLException {
0274: return current.getDate(columnName, cal);
0275: }
0276:
0277: public Time getTime(String columnName) throws SQLException {
0278: return current.getTime(columnName);
0279: }
0280:
0281: public Time getTime(String columnName, Calendar cal)
0282: throws SQLException {
0283: return current.getTime(columnName, cal);
0284: }
0285:
0286: public Timestamp getTimestamp(String columnName)
0287: throws SQLException {
0288: return current.getTimestamp(columnName);
0289: }
0290:
0291: public Timestamp getTimestamp(String columnName, Calendar cal)
0292: throws SQLException {
0293: return current.getTimestamp(columnName, cal);
0294: }
0295:
0296: public InputStream getAsciiStream(String columnName)
0297: throws SQLException {
0298: return current.getAsciiStream(columnName);
0299: }
0300:
0301: public InputStream getUnicodeStream(String columnName)
0302: throws SQLException {
0303: return current.getUnicodeStream(columnName);
0304: }
0305:
0306: public InputStream getBinaryStream(String columnName)
0307: throws SQLException {
0308: return current.getBinaryStream(columnName);
0309: }
0310:
0311: public Reader getCharacterStream(String columnName)
0312: throws SQLException {
0313: return current.getCharacterStream(columnName);
0314: }
0315:
0316: public Reader getNCharacterStream(String columnName)
0317: throws SQLException {
0318: return current.getCharacterStream(columnName);
0319: }
0320:
0321: public Ref getRef(String columnName) throws SQLException {
0322: return current.getRef(columnName);
0323: }
0324:
0325: /*public RowId getRowId(String columnName) throws SQLException
0326: {
0327: return current.getRowId(columnName);
0328: }*/
0329:
0330: public Blob getBlob(String columnName) throws SQLException {
0331: return current.getBlob(columnName);
0332: }
0333:
0334: public Clob getClob(String columnName) throws SQLException {
0335: return current.getClob(columnName);
0336: }
0337:
0338: /*public NClob getNClob(String columnName) throws SQLException
0339: {
0340: return current.getNClob(columnName);
0341: }*/
0342:
0343: /*public SQLXML getSQLXML(String columnName) throws SQLException
0344: {
0345: return current.getSQLXML(columnName);
0346: }*/
0347:
0348: public Array getArray(String colName) throws SQLException {
0349: return current.getArray(colName);
0350: }
0351:
0352: public URL getURL(String columnName) throws SQLException {
0353: return current.getURL(columnName);
0354: }
0355:
0356: public Object getObject(String columnName) throws SQLException {
0357: return current.getObject(columnName);
0358: }
0359:
0360: public Object getObject(String columnName, Map map)
0361: throws SQLException {
0362: return current.getObject(columnName, map);
0363: }
0364:
0365: public SQLWarning getWarnings() throws SQLException {
0366: return current.getWarnings();
0367: }
0368:
0369: public void clearWarnings() throws SQLException {
0370: current.clearWarnings();
0371: }
0372:
0373: public String getCursorName() throws SQLException {
0374: return current.getCursorName();
0375: }
0376:
0377: public ResultSetMetaData getMetaData() throws SQLException {
0378: return current.getMetaData();
0379: }
0380:
0381: public int findColumn(String columnName) throws SQLException {
0382: return current.findColumn(columnName);
0383: }
0384:
0385: public boolean isBeforeFirst() throws SQLException {
0386: return current.isBeforeFirst();
0387: }
0388:
0389: public boolean isAfterLast() throws SQLException {
0390: return current.isAfterLast();
0391: }
0392:
0393: public boolean isFirst() throws SQLException {
0394: return current.isFirst();
0395: }
0396:
0397: public boolean isLast() throws SQLException {
0398: return current.isLast();
0399: }
0400:
0401: public void beforeFirst() throws SQLException {
0402: current.beforeFirst();
0403: }
0404:
0405: public void afterLast() throws SQLException {
0406: current.afterLast();
0407: }
0408:
0409: public boolean first() throws SQLException {
0410: throw new SQLException("Not allowed for "
0411: + PolyResultSet.class.getName());
0412: }
0413:
0414: public boolean last() throws SQLException {
0415: throw new SQLException("Not allowed for "
0416: + PolyResultSet.class.getName());
0417: }
0418:
0419: public int getRow() throws SQLException {
0420: throw new SQLException("Not allowed for "
0421: + PolyResultSet.class.getName());
0422: }
0423:
0424: public boolean absolute(int row) throws SQLException {
0425: throw new SQLException("Not allowed for "
0426: + PolyResultSet.class.getName());
0427: }
0428:
0429: public boolean relative(int rows) throws SQLException {
0430: throw new SQLException("Not allowed for "
0431: + PolyResultSet.class.getName());
0432: }
0433:
0434: public boolean previous() throws SQLException {
0435: throw new SQLException("Not allowed for "
0436: + PolyResultSet.class.getName());
0437: }
0438:
0439: public void setFetchDirection(int direction) throws SQLException {
0440: throw new SQLException("Not allowed for "
0441: + PolyResultSet.class.getName());
0442: }
0443:
0444: public int getFetchDirection() throws SQLException {
0445: return current.getFetchDirection();
0446: }
0447:
0448: public void setFetchSize(int rows) throws SQLException {
0449: throw new SQLException("Not allowed for "
0450: + PolyResultSet.class.getName());
0451: }
0452:
0453: public int getFetchSize() throws SQLException {
0454: return current.getFetchSize();
0455: }
0456:
0457: public int getType() throws SQLException {
0458: return current.getType();
0459: }
0460:
0461: public int getConcurrency() throws SQLException {
0462: return current.getConcurrency();
0463: }
0464:
0465: /*public int getHoldability() throws SQLException
0466: {
0467: return current.getHoldability();
0468: }*/
0469:
0470: public boolean rowUpdated() throws SQLException {
0471: return current.rowUpdated();
0472: }
0473:
0474: public boolean rowInserted() throws SQLException {
0475: return current.rowInserted();
0476: }
0477:
0478: public boolean rowDeleted() throws SQLException {
0479: return current.rowDeleted();
0480: }
0481:
0482: public void insertRow() throws SQLException {
0483: throw new SQLException("Not allowed for "
0484: + PolyResultSet.class.getName());
0485: }
0486:
0487: public void updateRow() throws SQLException {
0488: throw new SQLException("Not allowed for "
0489: + PolyResultSet.class.getName());
0490: }
0491:
0492: public void deleteRow() throws SQLException {
0493: throw new SQLException("Not allowed for "
0494: + PolyResultSet.class.getName());
0495: }
0496:
0497: public void refreshRow() throws SQLException {
0498: throw new SQLException("Not allowed for "
0499: + PolyResultSet.class.getName());
0500: }
0501:
0502: public void cancelRowUpdates() throws SQLException {
0503: throw new SQLException("Not allowed for "
0504: + PolyResultSet.class.getName());
0505: }
0506:
0507: public void moveToInsertRow() throws SQLException {
0508: throw new SQLException("Not allowed for "
0509: + PolyResultSet.class.getName());
0510: }
0511:
0512: public void moveToCurrentRow() throws SQLException {
0513: throw new SQLException("Not allowed for "
0514: + PolyResultSet.class.getName());
0515: }
0516:
0517: public Statement getStatement() throws SQLException {
0518: throw new SQLException("Not allowed for "
0519: + PolyResultSet.class.getName());
0520: }
0521:
0522: public void updateNull(int columnIndex) throws SQLException {
0523: throw new SQLException("Not allowed for "
0524: + PolyResultSet.class.getName());
0525: }
0526:
0527: public void updateBoolean(int columnIndex, boolean value)
0528: throws SQLException {
0529: throw new SQLException("Not allowed for "
0530: + PolyResultSet.class.getName());
0531: }
0532:
0533: public void updateByte(int columnIndex, byte value)
0534: throws SQLException {
0535: throw new SQLException("Not allowed for "
0536: + PolyResultSet.class.getName());
0537: }
0538:
0539: public void updateShort(int columnIndex, short value)
0540: throws SQLException {
0541: throw new SQLException("Not allowed for "
0542: + PolyResultSet.class.getName());
0543: }
0544:
0545: public void updateInt(int columnIndex, int value)
0546: throws SQLException {
0547: throw new SQLException("Not allowed for "
0548: + PolyResultSet.class.getName());
0549: }
0550:
0551: public void updateLong(int columnIndex, long value)
0552: throws SQLException {
0553: throw new SQLException("Not allowed for "
0554: + PolyResultSet.class.getName());
0555: }
0556:
0557: public void updateFloat(int columnIndex, float value)
0558: throws SQLException {
0559: throw new SQLException("Not allowed for "
0560: + PolyResultSet.class.getName());
0561: }
0562:
0563: public void updateDouble(int columnIndex, double value)
0564: throws SQLException {
0565: throw new SQLException("Not allowed for "
0566: + PolyResultSet.class.getName());
0567: }
0568:
0569: public void updateBigDecimal(int columnIndex, BigDecimal value)
0570: throws SQLException {
0571: throw new SQLException("Not allowed for "
0572: + PolyResultSet.class.getName());
0573: }
0574:
0575: public void updateString(int columnIndex, String value)
0576: throws SQLException {
0577: throw new SQLException("Not allowed for "
0578: + PolyResultSet.class.getName());
0579: }
0580:
0581: public void updateNString(int columnIndex, String value)
0582: throws SQLException {
0583: throw new SQLException("Not allowed for "
0584: + PolyResultSet.class.getName());
0585: }
0586:
0587: public void updateBytes(int columnIndex, byte value[])
0588: throws SQLException {
0589: throw new SQLException("Not allowed for "
0590: + PolyResultSet.class.getName());
0591: }
0592:
0593: public void updateDate(int columnIndex, Date value)
0594: throws SQLException {
0595: throw new SQLException("Not allowed for "
0596: + PolyResultSet.class.getName());
0597: }
0598:
0599: public void updateTime(int columnIndex, Time value)
0600: throws SQLException {
0601: throw new SQLException("Not allowed for "
0602: + PolyResultSet.class.getName());
0603: }
0604:
0605: public void updateTimestamp(int columnIndex, Timestamp value)
0606: throws SQLException {
0607: throw new SQLException("Not allowed for "
0608: + PolyResultSet.class.getName());
0609: }
0610:
0611: public void updateAsciiStream(int columnIndex, InputStream stream,
0612: int length) throws SQLException {
0613: throw new SQLException("Not allowed for "
0614: + PolyResultSet.class.getName());
0615: }
0616:
0617: public void updateAsciiStream(int columnIndex, InputStream stream,
0618: long length) throws SQLException {
0619: throw new SQLException("Not allowed for "
0620: + PolyResultSet.class.getName());
0621: }
0622:
0623: public void updateAsciiStream(int columnIndex, InputStream stream)
0624: throws SQLException {
0625: throw new SQLException("Not allowed for "
0626: + PolyResultSet.class.getName());
0627: }
0628:
0629: public void updateBinaryStream(int columnIndex, InputStream stream,
0630: int length) throws SQLException {
0631: throw new SQLException("Not allowed for "
0632: + PolyResultSet.class.getName());
0633: }
0634:
0635: public void updateBinaryStream(int columnIndex, InputStream stream,
0636: long length) throws SQLException {
0637: throw new SQLException("Not allowed for "
0638: + PolyResultSet.class.getName());
0639: }
0640:
0641: public void updateBinaryStream(int columnIndex, InputStream stream)
0642: throws SQLException {
0643: throw new SQLException("Not allowed for "
0644: + PolyResultSet.class.getName());
0645: }
0646:
0647: public void updateCharacterStream(int columnIndex, Reader reader,
0648: int length) throws SQLException {
0649: throw new SQLException("Not allowed for "
0650: + PolyResultSet.class.getName());
0651: }
0652:
0653: public void updateCharacterStream(int columnIndex, Reader reader,
0654: long length) throws SQLException {
0655: throw new SQLException("Not allowed for "
0656: + PolyResultSet.class.getName());
0657: }
0658:
0659: public void updateCharacterStream(int columnIndex, Reader reader)
0660: throws SQLException {
0661: throw new SQLException("Not allowed for "
0662: + PolyResultSet.class.getName());
0663: }
0664:
0665: public void updateNCharacterStream(int columnIndex, Reader x,
0666: long length) throws SQLException {
0667: throw new SQLException("Not allowed for "
0668: + PolyResultSet.class.getName());
0669: }
0670:
0671: public void updateNCharacterStream(int columnIndex, Reader x)
0672: throws SQLException {
0673: throw new SQLException("Not allowed for "
0674: + PolyResultSet.class.getName());
0675: }
0676:
0677: public void updateRef(int columnIndex, Ref value)
0678: throws SQLException {
0679: throw new SQLException("Not allowed for "
0680: + PolyResultSet.class.getName());
0681: }
0682:
0683: /*public void updateRowId(int columnIndex, RowId x) throws SQLException
0684: {
0685: throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
0686: }*/
0687:
0688: public void updateBlob(int columnIndex, InputStream stream,
0689: long length) throws SQLException {
0690: throw new SQLException("Not allowed for "
0691: + PolyResultSet.class.getName());
0692: }
0693:
0694: public void updateBlob(int columnIndex, Blob value)
0695: throws SQLException {
0696: throw new SQLException("Not allowed for "
0697: + PolyResultSet.class.getName());
0698: }
0699:
0700: public void updateBlob(int columnIndex, InputStream stream)
0701: throws SQLException {
0702: throw new SQLException("Not allowed for "
0703: + PolyResultSet.class.getName());
0704: }
0705:
0706: public void updateClob(int columnIndex, Clob value)
0707: throws SQLException {
0708: throw new SQLException("Not allowed for "
0709: + PolyResultSet.class.getName());
0710: }
0711:
0712: public void updateClob(int columnIndex, Reader reader, long length)
0713: throws SQLException {
0714: throw new SQLException("Not allowed for "
0715: + PolyResultSet.class.getName());
0716: }
0717:
0718: public void updateClob(int columnIndex, Reader reader)
0719: throws SQLException {
0720: throw new SQLException("Not allowed for "
0721: + PolyResultSet.class.getName());
0722: }
0723:
0724: /*public void updateNClob(int columnIndex, NClob nClob) throws SQLException
0725: {
0726: throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
0727: }*/
0728:
0729: public void updateNClob(int columnIndex, Reader reader, long length)
0730: throws SQLException {
0731: throw new SQLException("Not allowed for "
0732: + PolyResultSet.class.getName());
0733: }
0734:
0735: public void updateNClob(int columnIndex, Reader reader)
0736: throws SQLException {
0737: throw new SQLException("Not allowed for "
0738: + PolyResultSet.class.getName());
0739: }
0740:
0741: /*public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException
0742: {
0743: throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
0744: }*/
0745:
0746: public void updateArray(int columnIndex, Array value)
0747: throws SQLException {
0748: throw new SQLException("Not allowed for "
0749: + PolyResultSet.class.getName());
0750: }
0751:
0752: public void updateObject(int columnIndex, Object x, int scale)
0753: throws SQLException {
0754: throw new SQLException("Not allowed for "
0755: + PolyResultSet.class.getName());
0756: }
0757:
0758: public void updateObject(int columnIndex, Object x)
0759: throws SQLException {
0760: throw new SQLException("Not allowed for "
0761: + PolyResultSet.class.getName());
0762: }
0763:
0764: public void updateAsciiStream(String columnName,
0765: InputStream stream, int length) throws SQLException {
0766: throw new SQLException("Not allowed for "
0767: + PolyResultSet.class.getName());
0768: }
0769:
0770: public void updateAsciiStream(String columnName, InputStream stream)
0771: throws SQLException {
0772: throw new SQLException("Not allowed for "
0773: + PolyResultSet.class.getName());
0774: }
0775:
0776: public void updateAsciiStream(String columnName,
0777: InputStream stream, long length) throws SQLException {
0778: throw new SQLException("Not allowed for "
0779: + PolyResultSet.class.getName());
0780: }
0781:
0782: public void updateBinaryStream(String columnName,
0783: InputStream stream, long length) throws SQLException {
0784: throw new SQLException("Not allowed for "
0785: + PolyResultSet.class.getName());
0786: }
0787:
0788: public void updateBinaryStream(String columnName, InputStream stream)
0789: throws SQLException {
0790: throw new SQLException("Not allowed for "
0791: + PolyResultSet.class.getName());
0792: }
0793:
0794: public void updateCharacterStream(String columnName, Reader reader,
0795: int length) throws SQLException {
0796: throw new SQLException("Not allowed for "
0797: + PolyResultSet.class.getName());
0798: }
0799:
0800: public void updateCharacterStream(String columnName, Reader reader,
0801: long length) throws SQLException {
0802: throw new SQLException("Not allowed for "
0803: + PolyResultSet.class.getName());
0804: }
0805:
0806: public void updateCharacterStream(String columnName, Reader reader)
0807: throws SQLException {
0808: throw new SQLException("Not allowed for "
0809: + PolyResultSet.class.getName());
0810: }
0811:
0812: public void updateNCharacterStream(String columnName,
0813: Reader reader, long length) throws SQLException {
0814: throw new SQLException("Not allowed for "
0815: + PolyResultSet.class.getName());
0816: }
0817:
0818: public void updateNCharacterStream(String columnName, Reader reader)
0819: throws SQLException {
0820: throw new SQLException("Not allowed for "
0821: + PolyResultSet.class.getName());
0822: }
0823:
0824: public void updateNull(String columnName) throws SQLException {
0825: throw new SQLException("Not allowed for "
0826: + PolyResultSet.class.getName());
0827: }
0828:
0829: public void updateBoolean(String columnName, boolean value)
0830: throws SQLException {
0831: throw new SQLException("Not allowed for "
0832: + PolyResultSet.class.getName());
0833: }
0834:
0835: public void updateByte(String columnName, byte value)
0836: throws SQLException {
0837: throw new SQLException("Not allowed for "
0838: + PolyResultSet.class.getName());
0839: }
0840:
0841: public void updateShort(String columnName, short value)
0842: throws SQLException {
0843: throw new SQLException("Not allowed for "
0844: + PolyResultSet.class.getName());
0845: }
0846:
0847: public void updateInt(String columnName, int value)
0848: throws SQLException {
0849: throw new SQLException("Not allowed for "
0850: + PolyResultSet.class.getName());
0851: }
0852:
0853: public void updateLong(String columnName, long value)
0854: throws SQLException {
0855: throw new SQLException("Not allowed for "
0856: + PolyResultSet.class.getName());
0857: }
0858:
0859: public void updateFloat(String columnName, float value)
0860: throws SQLException {
0861: throw new SQLException("Not allowed for "
0862: + PolyResultSet.class.getName());
0863: }
0864:
0865: public void updateDouble(String columnName, double value)
0866: throws SQLException {
0867: throw new SQLException("Not allowed for "
0868: + PolyResultSet.class.getName());
0869: }
0870:
0871: public void updateBigDecimal(String columnName, BigDecimal value)
0872: throws SQLException {
0873: throw new SQLException("Not allowed for "
0874: + PolyResultSet.class.getName());
0875: }
0876:
0877: public void updateString(String columnName, String value)
0878: throws SQLException {
0879: throw new SQLException("Not allowed for "
0880: + PolyResultSet.class.getName());
0881: }
0882:
0883: public void updateNString(String columnName, String value)
0884: throws SQLException {
0885: throw new SQLException("Not allowed for "
0886: + PolyResultSet.class.getName());
0887: }
0888:
0889: public void updateBytes(String columnName, byte value[])
0890: throws SQLException {
0891: throw new SQLException("Not allowed for "
0892: + PolyResultSet.class.getName());
0893: }
0894:
0895: public void updateDate(String columnName, Date value)
0896: throws SQLException {
0897: throw new SQLException("Not allowed for "
0898: + PolyResultSet.class.getName());
0899: }
0900:
0901: public void updateTime(String columnName, Time value)
0902: throws SQLException {
0903: throw new SQLException("Not allowed for "
0904: + PolyResultSet.class.getName());
0905: }
0906:
0907: public void updateTimestamp(String columnName, Timestamp value)
0908: throws SQLException {
0909: throw new SQLException("Not allowed for "
0910: + PolyResultSet.class.getName());
0911: }
0912:
0913: public void updateBinaryStream(String columnName,
0914: InputStream value, int length) throws SQLException {
0915: throw new SQLException("Not allowed for "
0916: + PolyResultSet.class.getName());
0917: }
0918:
0919: public void updateRef(String columnName, Ref value)
0920: throws SQLException {
0921: throw new SQLException("Not allowed for "
0922: + PolyResultSet.class.getName());
0923: }
0924:
0925: /*public void updateRowId(String columnName, RowId value) throws SQLException
0926: {
0927: throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
0928: }*/
0929:
0930: public void updateBlob(String columnName, Blob value)
0931: throws SQLException {
0932: throw new SQLException("Not allowed for "
0933: + PolyResultSet.class.getName());
0934: }
0935:
0936: public void updateBlob(String columnName, InputStream stream,
0937: long length) throws SQLException {
0938: throw new SQLException("Not allowed for "
0939: + PolyResultSet.class.getName());
0940: }
0941:
0942: public void updateBlob(String columnName, InputStream stream)
0943: throws SQLException {
0944: throw new SQLException("Not allowed for "
0945: + PolyResultSet.class.getName());
0946: }
0947:
0948: public void updateClob(String columnName, Clob value)
0949: throws SQLException {
0950: throw new SQLException("Not allowed for "
0951: + PolyResultSet.class.getName());
0952: }
0953:
0954: public void updateClob(String columnName, Reader reader, long length)
0955: throws SQLException {
0956: throw new SQLException("Not allowed for "
0957: + PolyResultSet.class.getName());
0958: }
0959:
0960: public void updateClob(String columnName, Reader reader)
0961: throws SQLException {
0962: throw new SQLException("Not allowed for "
0963: + PolyResultSet.class.getName());
0964: }
0965:
0966: /*public void updateNClob(String columnName, NClob nClob) throws SQLException
0967: {
0968: throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
0969: }*/
0970:
0971: public void updateNClob(String columnName, Reader reader,
0972: long length) throws SQLException {
0973: throw new SQLException("Not allowed for "
0974: + PolyResultSet.class.getName());
0975: }
0976:
0977: public void updateNClob(String columnName, Reader reader)
0978: throws SQLException {
0979: throw new SQLException("Not allowed for "
0980: + PolyResultSet.class.getName());
0981: }
0982:
0983: /*public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException
0984: {
0985: throw new SQLException("Not allowed for " + PolyResultSet.class.getName());
0986: }*/
0987:
0988: public void updateArray(String columnName, Array value)
0989: throws SQLException {
0990: throw new SQLException("Not allowed for "
0991: + PolyResultSet.class.getName());
0992: }
0993:
0994: public void updateObject(String columnName, Object value, int scale)
0995: throws SQLException {
0996: throw new SQLException("Not allowed for "
0997: + PolyResultSet.class.getName());
0998: }
0999:
1000: public void updateObject(String columnName, Object value)
1001: throws SQLException {
1002: throw new SQLException("Not allowed for "
1003: + PolyResultSet.class.getName());
1004: }
1005:
1006: public boolean isWrapperFor(Class iface) throws SQLException {
1007: return false;
1008: }
1009:
1010: public Object unwrap(Class iface) throws SQLException {
1011: throw new SQLException("No object found for " + iface);
1012: }
1013: }
|