0001: /*
0002: * The contents of this file are subject to the
0003: * Mozilla Public License Version 1.1 (the "License");
0004: * you may not use this file except in compliance with the License.
0005: * You may obtain a copy of the License at 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.
0009: * See the License for the specific language governing rights and
0010: * limitations under the License.
0011: *
0012: * The Initial Developer of the Original Code is Simulacra Media Ltd.
0013: * Portions created by Simulacra Media Ltd are Copyright (C) Simulacra Media Ltd, 2004.
0014: *
0015: * All Rights Reserved.
0016: *
0017: * Contributor(s):
0018: */
0019: package org.openharmonise.commons.dsi;
0020:
0021: import java.io.InputStream;
0022: import java.io.Reader;
0023: import java.math.BigDecimal;
0024: import java.net.URL;
0025: import java.sql.*;
0026: import java.sql.Date;
0027:
0028: import java.util.*;
0029:
0030: /**
0031: * A result set that caches the data retrieved from a SQL query. Unlike the
0032: * <code>java.sql.ResultSet<code> the order of data access does not matter
0033: * and can be accessed more than once.
0034: *
0035: * <b>Warning: only the most commonly used get methods have been implemented.</b>
0036: *
0037: * @author Michael Bell
0038: * @version $Revision: 1.2 $
0039: *
0040: */
0041: public class CachedResultSet implements ResultSet, Cloneable {
0042:
0043: /**
0044: * List of column names
0045: */
0046: protected List m_colNames = new Vector();
0047:
0048: /**
0049: * List of column data types
0050: */
0051: protected List m_colTypes = new Vector();
0052:
0053: /**
0054: * List of rows of result set
0055: */
0056: protected List m_rows = new Vector();
0057:
0058: /**
0059: * Current row of data
0060: */
0061: protected List m_currentrow = null; //vector of values
0062:
0063: /**
0064: * List of rows read
0065: */
0066: protected List m_readMarks = new Vector();
0067:
0068: /**
0069: * Index of current row in list of rows
0070: */
0071: protected int m_mark = -1;
0072:
0073: /**
0074: * Number of rows
0075: */
0076: protected int m_resultTotal = -1;
0077:
0078: /**
0079: * Constructs empty result set
0080: *
0081: */
0082: public CachedResultSet() {
0083: }
0084:
0085: /**
0086: * Constructs cached result set from the given <code>ResultSet</code>.
0087: *
0088: * @param rs the result set to cache
0089: * @throws DataStoreException if an error occurs loading data
0090: */
0091: public CachedResultSet(ResultSet rs) throws DataStoreException {
0092: loadResultSet(rs, -1);
0093: }
0094:
0095: /**
0096: * Constructs a cached result set from the given <code>ResultSet</code>,
0097: * caching only the number of rows specified.
0098: *
0099: * @param rs the result set to cache
0100: * @param numrows the number of rows to cache
0101: * @throws DataStoreException if an error occurs loading data
0102: */
0103: public CachedResultSet(ResultSet rs, int numrows)
0104: throws DataStoreException {
0105: loadResultSet(rs, numrows);
0106: }
0107:
0108: /* (non-Javadoc)
0109: * @see java.lang.Object#clone()
0110: */
0111: public Object clone() {
0112: try {
0113: return super .clone();
0114: } catch (CloneNotSupportedException e) {
0115: return null;
0116: } catch (Exception e) {
0117: //not sure what we should do here
0118: return null;
0119: }
0120: }
0121:
0122: /**
0123: * Caches the given <code>ResultSet</code>.
0124: *
0125: * @param rs the result set to cache
0126: * @throws DataStoreException if an error occurs loading the data
0127: */
0128: public void cacheResultSet(ResultSet rs) throws DataStoreException {
0129: initialise();
0130: loadResultSet(rs, -1);
0131: }
0132:
0133: /**
0134: * Cache the specified number of rows from the given <code>ResultSet</code>.
0135: *
0136: * @param rs the result set to cache
0137: * @param numrows the number of rows to cache
0138: * @throws DataStoreException if an error occurs loading data
0139: */
0140: public void cacheResultSet(ResultSet rs, int numrows)
0141: throws DataStoreException {
0142: initialise();
0143: loadResultSet(rs, numrows);
0144: }
0145:
0146: /* (non-Javadoc)
0147: * @see java.sql.ResultSet#next()
0148: */
0149: public boolean next() {
0150: return setCurrentRow(++m_mark);
0151: }
0152:
0153: /* (non-Javadoc)
0154: * @see java.sql.ResultSet#previous()
0155: */
0156: public boolean previous() {
0157: return setCurrentRow(--m_mark);
0158: }
0159:
0160: /**
0161: * Sets the current row.
0162: *
0163: * @param nIndex the index of the current row
0164: */
0165: public void setStartRow(int nIndex) {
0166: m_mark = nIndex - 1;
0167: }
0168:
0169: /**
0170: * Marks the current row as read.
0171: */
0172: public void markCurrentRowAsRead() {
0173: if ((m_mark >= 0) && (m_mark < this .m_readMarks.size())) {
0174: this .m_readMarks.set(m_mark, new Boolean(true));
0175: }
0176: }
0177:
0178: /**
0179: * Clears the current row.
0180: *
0181: */
0182: public void clearRow() {
0183: for (int i = 0; i < m_currentrow.size(); i++) {
0184: m_currentrow.set(i, null);
0185: }
0186: }
0187:
0188: /**
0189: * Clears the current row, except for the specified column.
0190: *
0191: * @param columnToLeave the name of the column to retain
0192: */
0193: public void clearRow(String columnToLeave) {
0194: for (int i = 0; i < m_currentrow.size(); i++) {
0195: String sCol = (String) m_colNames.get(i);
0196:
0197: if (sCol.equals(columnToLeave) == false) {
0198: m_currentrow.set(i, null);
0199: }
0200: }
0201: }
0202:
0203: /**
0204: * Clears the current row, except for the specified columns.
0205: *
0206: * @param columnsToLeave list of names of columns to retain
0207: */
0208: public void clearRow(List columnsToLeave) {
0209: for (int i = 0; i < m_currentrow.size(); i++) {
0210: String sCol = (String) m_colNames.get(i);
0211:
0212: if (columnsToLeave.contains(sCol) == false) {
0213: m_currentrow.set(i, null);
0214: }
0215: }
0216: }
0217:
0218: /**
0219: * Removes result set row from this result set.
0220: *
0221: * @param index the index of the row to remove
0222: */
0223: public void removeRow(int index) {
0224: if ((index >= 0) && (index < m_rows.size())) {
0225: m_rows.remove(index);
0226: m_readMarks.remove(index);
0227: m_resultTotal--;
0228:
0229: if (m_mark == index) {
0230: m_mark--;
0231: this .m_currentrow = (List) m_rows.get(m_mark);
0232: }
0233: }
0234: }
0235:
0236: /**
0237: * Returns <code>true</code> if the current row has been read.
0238: *
0239: * @return <code>true</code> if the current row has been read.
0240: */
0241: public boolean hasCurrentRowBeenRead() {
0242: boolean bReturn = false;
0243:
0244: if ((m_mark >= 0) && (m_mark < this .m_readMarks.size())) {
0245: bReturn = ((Boolean) m_readMarks.get(m_mark))
0246: .booleanValue();
0247: }
0248:
0249: return bReturn;
0250: }
0251:
0252: /* (non-Javadoc)
0253: * @see java.sql.ResultSet#getInt(java.lang.String)
0254: */
0255: public int getInt(String sName) {
0256: int nReturn = -1;
0257: Integer Ival = (Integer) getColumnValue(sName);
0258:
0259: if (Ival != null) {
0260: nReturn = Ival.intValue();
0261: }
0262:
0263: return nReturn;
0264: }
0265:
0266: /* (non-Javadoc)
0267: * @see java.sql.ResultSet#getInt(int)
0268: */
0269: public int getInt(int nIndex) {
0270: int nReturn = -1;
0271: Integer Ival = (Integer) getColumnValue(nIndex);
0272:
0273: if (Ival != null) {
0274: nReturn = Ival.intValue();
0275: }
0276:
0277: return nReturn;
0278: }
0279:
0280: /* (non-Javadoc)
0281: * @see java.sql.ResultSet#getString(java.lang.String)
0282: */
0283: public String getString(String sName) {
0284: return (String) getColumnValue(sName);
0285: }
0286:
0287: /* (non-Javadoc)
0288: * @see java.sql.ResultSet#getString(int)
0289: */
0290: public String getString(int nIndex) {
0291: return (String) getColumnValue(nIndex);
0292: }
0293:
0294: /* (non-Javadoc)
0295: * @see java.sql.ResultSet#getDate(java.lang.String)
0296: */
0297: public java.sql.Date getDate(String sName) {
0298: return (java.sql.Date) getColumnValue(sName);
0299: }
0300:
0301: /* (non-Javadoc)
0302: * @see java.sql.ResultSet#getDate(int)
0303: */
0304: public java.sql.Date getDate(int nIndex) {
0305: return (java.sql.Date) getColumnValue(nIndex);
0306: }
0307:
0308: /* (non-Javadoc)
0309: * @see java.sql.ResultSet#getBoolean(java.lang.String)
0310: */
0311: public boolean getBoolean(String sName) {
0312: boolean bReturn = false;
0313: Boolean Bval = null;
0314: Object obj = getColumnValue(sName);
0315:
0316: if (obj instanceof Boolean) {
0317: Bval = (Boolean) obj;
0318:
0319: if (Bval != null) {
0320: bReturn = Bval.booleanValue();
0321: }
0322: } else if (obj instanceof Integer) {
0323: if (((Integer) obj).intValue() > 0) {
0324: bReturn = true;
0325: } else {
0326: bReturn = false;
0327: }
0328: }
0329:
0330: return bReturn;
0331: }
0332:
0333: /* (non-Javadoc)
0334: * @see java.sql.ResultSet#getBoolean(int)
0335: */
0336: public boolean getBoolean(int nIndex) {
0337: boolean bReturn = false;
0338:
0339: Boolean Bval = (Boolean) getColumnValue(nIndex);
0340:
0341: if (Bval != null) {
0342: bReturn = Bval.booleanValue();
0343: }
0344:
0345: return bReturn;
0346: }
0347:
0348: /**
0349: * Returns the number of rows in this result set.
0350: *
0351: * @return the number of rows in this result set
0352: */
0353: public int getResultTotal() {
0354: return m_rows.size();
0355: }
0356:
0357: /**
0358: * Sets the current row.
0359: *
0360: * @param nIndex the index of the current row
0361: * @return <code>true</code> if the operation was successful
0362: */
0363: private boolean setCurrentRow(int nIndex) {
0364: boolean bReturn = false;
0365:
0366: if (m_rows.size() > nIndex) {
0367: bReturn = true;
0368: m_currentrow = (Vector) m_rows.get(nIndex);
0369: }
0370:
0371: return bReturn;
0372: }
0373:
0374: /**
0375: * Returns the value of the specified column in the current row.
0376: *
0377: * @param sName the name of the column
0378: * @return the value of the column in the current row
0379: */
0380: private Object getColumnValue(String sName) {
0381: Object obj = null;
0382: int nIndex = this .m_colNames.indexOf(sName.toLowerCase());
0383:
0384: if (nIndex >= 0) {
0385: obj = m_currentrow.get(nIndex);
0386: }
0387:
0388: return obj;
0389: }
0390:
0391: /**
0392: * Returns the value of the specified column in the current row.
0393: *
0394: * @param nIndex the index of the column
0395: * @return value of the specified column in the current row
0396: */
0397: private Object getColumnValue(int nIndex) {
0398: Object obj = null;
0399:
0400: if ((nIndex >= 0) && (nIndex < m_currentrow.size())) {
0401: obj = m_currentrow.get(nIndex - 1);
0402: }
0403:
0404: return obj;
0405: }
0406:
0407: /**
0408: * Loads the given result set in to this result set.
0409: *
0410: * @param rs the result set to load
0411: * @param numRowsToLoad the number of row to load
0412: * @throws DataStoreException if an error occurs loading the data
0413: */
0414: private void loadResultSet(ResultSet rs, int numRowsToLoad)
0415: throws DataStoreException {
0416: try {
0417: ResultSetMetaData meta = rs.getMetaData();
0418:
0419: for (int i = 0; i < meta.getColumnCount(); i++) {
0420: int colNum = i + 1;
0421: m_colNames
0422: .add(meta.getColumnName(colNum).toLowerCase());
0423: m_colTypes.add(new Integer(meta.getColumnType(colNum)));
0424: }
0425:
0426: int nCount = 0;
0427: boolean bLoop = true;
0428:
0429: while (rs.next() && bLoop) {
0430: Vector row = new Vector(m_colNames.size());
0431:
0432: for (int i = 0; i < m_colNames.size(); i++) {
0433: int colType = ((Integer) m_colTypes.get(i))
0434: .intValue();
0435: int colNum = i + 1;
0436:
0437: if (colType == Types.INTEGER) {
0438: row.add(new Integer(rs.getInt(colNum)));
0439: } else if (colType == Types.NUMERIC) {
0440: row.add(new Integer(rs.getInt(colNum)));
0441: } else if ((colType == Types.VARCHAR)
0442: || (colType == Types.LONGVARCHAR)
0443: || colType == Types.CHAR) {
0444: row.add(rs.getString(colNum));
0445: } else if (colType == Types.BIT
0446: || colType == Types.SMALLINT) {
0447: row.add(new Boolean(rs.getBoolean(colNum)));
0448: } else if ((colType == Types.DATE)
0449: || (colType == Types.TIME)
0450: || (colType == Types.TIMESTAMP)) {
0451: row.add(rs.getDate(colNum));
0452: } else {
0453: throw new DataStoreException(
0454: "Unknown data type for column: "
0455: + colType);
0456: }
0457: }
0458:
0459: if (row.size() != m_colNames.size()) {
0460: throw new DataStoreException(
0461: "Not cached all columns (" + row.size()
0462: + " in cached row to "
0463: + m_colNames.size()
0464: + " in source row)");
0465: }
0466:
0467: this .m_rows.add(row);
0468: this .m_readMarks.add(new Boolean(false));
0469: nCount++;
0470:
0471: if (numRowsToLoad > 0) {
0472: if (nCount >= numRowsToLoad) {
0473: bLoop = false;
0474: }
0475: }
0476: }
0477: } catch (SQLException e) {
0478: throw new DataStoreException(e);
0479: }
0480:
0481: //System.out.println("Cached result set:\n" + this.toString());
0482: }
0483:
0484: /**
0485: * Initialises this result set.
0486: *
0487: */
0488: private void initialise() {
0489: m_colNames.clear();
0490: m_colTypes.clear();
0491: m_rows.clear();
0492:
0493: Vector m_currentrow = null;
0494: }
0495:
0496: /* (non-Javadoc)
0497: * @see java.lang.Object#toString()
0498: */
0499: public String toString() {
0500: StringBuffer sbuf = new StringBuffer();
0501:
0502: sbuf.append("columns:");
0503:
0504: for (int i = 0; i < this .m_colNames.size(); i++) {
0505: if (i > 0) {
0506: sbuf.append(",");
0507: }
0508:
0509: sbuf.append((String) m_colNames.get(i)).append("(").append(
0510: m_colTypes.get(i)).append(")");
0511: }
0512:
0513: sbuf.append("\n");
0514: sbuf.append("num rows:" + this .m_rows.size());
0515: sbuf.append("\n").append("current row:" + this .m_mark);
0516:
0517: return sbuf.toString();
0518: }
0519:
0520: /* (non-Javadoc)
0521: * @see java.sql.ResultSet#close()
0522: */
0523: public void close() throws SQLException {
0524: //do nothing as this a cached result set with
0525: //no live connection
0526: }
0527:
0528: /* (non-Javadoc)
0529: * @see java.sql.ResultSet#wasNull()
0530: */
0531: public boolean wasNull() throws SQLException {
0532: throw new UnsupportedOperationException();
0533: }
0534:
0535: /* (non-Javadoc)
0536: * @see java.sql.ResultSet#getByte(int)
0537: */
0538: public byte getByte(int arg0) throws SQLException {
0539: throw new UnsupportedOperationException();
0540: }
0541:
0542: /* (non-Javadoc)
0543: * @see java.sql.ResultSet#getShort(int)
0544: */
0545: public short getShort(int arg0) throws SQLException {
0546: throw new UnsupportedOperationException();
0547: }
0548:
0549: /* (non-Javadoc)
0550: * @see java.sql.ResultSet#getLong(int)
0551: */
0552: public long getLong(int arg0) throws SQLException {
0553: throw new UnsupportedOperationException();
0554: }
0555:
0556: /* (non-Javadoc)
0557: * @see java.sql.ResultSet#getFloat(int)
0558: */
0559: public float getFloat(int arg0) throws SQLException {
0560: throw new UnsupportedOperationException();
0561: }
0562:
0563: /* (non-Javadoc)
0564: * @see java.sql.ResultSet#getDouble(int)
0565: */
0566: public double getDouble(int arg0) throws SQLException {
0567: throw new UnsupportedOperationException();
0568: }
0569:
0570: /* (non-Javadoc)
0571: * @see java.sql.ResultSet#getBigDecimal(int, int)
0572: */
0573: public BigDecimal getBigDecimal(int arg0, int arg1)
0574: throws SQLException {
0575: throw new UnsupportedOperationException();
0576: }
0577:
0578: /* (non-Javadoc)
0579: * @see java.sql.ResultSet#getBytes(int)
0580: */
0581: public byte[] getBytes(int arg0) throws SQLException {
0582: throw new UnsupportedOperationException();
0583: }
0584:
0585: /* (non-Javadoc)
0586: * @see java.sql.ResultSet#getTime(int)
0587: */
0588: public Time getTime(int arg0) throws SQLException {
0589: throw new UnsupportedOperationException();
0590: }
0591:
0592: /* (non-Javadoc)
0593: * @see java.sql.ResultSet#getTimestamp(int)
0594: */
0595: public Timestamp getTimestamp(int arg0) throws SQLException {
0596: Timestamp val = null;
0597: Date dt = getDate(arg0);
0598:
0599: if (dt != null) {
0600: val = new Timestamp(dt.getTime());
0601: }
0602:
0603: return val;
0604: }
0605:
0606: /* (non-Javadoc)
0607: * @see java.sql.ResultSet#getAsciiStream(int)
0608: */
0609: public InputStream getAsciiStream(int arg0) throws SQLException {
0610: throw new UnsupportedOperationException();
0611: }
0612:
0613: /* (non-Javadoc)
0614: * @see java.sql.ResultSet#getUnicodeStream(int)
0615: */
0616: public InputStream getUnicodeStream(int arg0) throws SQLException {
0617: throw new UnsupportedOperationException();
0618: }
0619:
0620: /* (non-Javadoc)
0621: * @see java.sql.ResultSet#getBinaryStream(int)
0622: */
0623: public InputStream getBinaryStream(int arg0) throws SQLException {
0624: throw new UnsupportedOperationException();
0625: }
0626:
0627: /* (non-Javadoc)
0628: * @see java.sql.ResultSet#getByte(java.lang.String)
0629: */
0630: public byte getByte(String arg0) throws SQLException {
0631: throw new UnsupportedOperationException();
0632: }
0633:
0634: /* (non-Javadoc)
0635: * @see java.sql.ResultSet#getShort(java.lang.String)
0636: */
0637: public short getShort(String arg0) throws SQLException {
0638: throw new UnsupportedOperationException();
0639: }
0640:
0641: /* (non-Javadoc)
0642: * @see java.sql.ResultSet#getLong(java.lang.String)
0643: */
0644: public long getLong(String arg0) throws SQLException {
0645: throw new UnsupportedOperationException();
0646: }
0647:
0648: /* (non-Javadoc)
0649: * @see java.sql.ResultSet#getFloat(java.lang.String)
0650: */
0651: public float getFloat(String arg0) throws SQLException {
0652: throw new UnsupportedOperationException();
0653: }
0654:
0655: /* (non-Javadoc)
0656: * @see java.sql.ResultSet#getDouble(java.lang.String)
0657: */
0658: public double getDouble(String arg0) throws SQLException {
0659: throw new UnsupportedOperationException();
0660: }
0661:
0662: /* (non-Javadoc)
0663: * @see java.sql.ResultSet#getBigDecimal(java.lang.String, int)
0664: */
0665: public BigDecimal getBigDecimal(String arg0, int arg1)
0666: throws SQLException {
0667: throw new UnsupportedOperationException();
0668: }
0669:
0670: /* (non-Javadoc)
0671: * @see java.sql.ResultSet#getBytes(java.lang.String)
0672: */
0673: public byte[] getBytes(String arg0) throws SQLException {
0674: throw new UnsupportedOperationException();
0675: }
0676:
0677: /* (non-Javadoc)
0678: * @see java.sql.ResultSet#getTime(java.lang.String)
0679: */
0680: public Time getTime(String arg0) throws SQLException {
0681: throw new UnsupportedOperationException();
0682: }
0683:
0684: /* (non-Javadoc)
0685: * @see java.sql.ResultSet#getTimestamp(java.lang.String)
0686: */
0687: public Timestamp getTimestamp(String arg0) throws SQLException {
0688: Timestamp val = null;
0689: Date dt = getDate(arg0);
0690:
0691: if (dt != null) {
0692: val = new Timestamp(dt.getTime());
0693: }
0694:
0695: return val;
0696: }
0697:
0698: /* (non-Javadoc)
0699: * @see java.sql.ResultSet#getAsciiStream(java.lang.String)
0700: */
0701: public InputStream getAsciiStream(String arg0) throws SQLException {
0702: throw new UnsupportedOperationException();
0703: }
0704:
0705: /* (non-Javadoc)
0706: * @see java.sql.ResultSet#getUnicodeStream(java.lang.String)
0707: */
0708: public InputStream getUnicodeStream(String arg0)
0709: throws SQLException {
0710: throw new UnsupportedOperationException();
0711: }
0712:
0713: /* (non-Javadoc)
0714: * @see java.sql.ResultSet#getBinaryStream(java.lang.String)
0715: */
0716: public InputStream getBinaryStream(String arg0) throws SQLException {
0717: throw new UnsupportedOperationException();
0718: }
0719:
0720: /* (non-Javadoc)
0721: * @see java.sql.ResultSet#getWarnings()
0722: */
0723: public SQLWarning getWarnings() throws SQLException {
0724: throw new UnsupportedOperationException();
0725: }
0726:
0727: /* (non-Javadoc)
0728: * @see java.sql.ResultSet#clearWarnings()
0729: */
0730: public void clearWarnings() throws SQLException {
0731: //do nothing - there was no warnings
0732: }
0733:
0734: /* (non-Javadoc)
0735: * @see java.sql.ResultSet#getCursorName()
0736: */
0737: public String getCursorName() throws SQLException {
0738: throw new UnsupportedOperationException();
0739: }
0740:
0741: /* (non-Javadoc)
0742: * @see java.sql.ResultSet#getMetaData()
0743: */
0744: public ResultSetMetaData getMetaData() throws SQLException {
0745: throw new UnsupportedOperationException();
0746: }
0747:
0748: /* (non-Javadoc)
0749: * @see java.sql.ResultSet#getObject(int)
0750: */
0751: public Object getObject(int arg0) throws SQLException {
0752: throw new UnsupportedOperationException();
0753: }
0754:
0755: /* (non-Javadoc)
0756: * @see java.sql.ResultSet#getObject(java.lang.String)
0757: */
0758: public Object getObject(String arg0) throws SQLException {
0759: throw new UnsupportedOperationException();
0760: }
0761:
0762: /* (non-Javadoc)
0763: * @see java.sql.ResultSet#findColumn(java.lang.String)
0764: */
0765: public int findColumn(String arg0) throws SQLException {
0766: throw new UnsupportedOperationException();
0767: }
0768:
0769: /* (non-Javadoc)
0770: * @see java.sql.ResultSet#getCharacterStream(int)
0771: */
0772: public Reader getCharacterStream(int arg0) throws SQLException {
0773: throw new UnsupportedOperationException();
0774: }
0775:
0776: /* (non-Javadoc)
0777: * @see java.sql.ResultSet#getCharacterStream(java.lang.String)
0778: */
0779: public Reader getCharacterStream(String arg0) throws SQLException {
0780: throw new UnsupportedOperationException();
0781: }
0782:
0783: /* (non-Javadoc)
0784: * @see java.sql.ResultSet#getBigDecimal(int)
0785: */
0786: public BigDecimal getBigDecimal(int arg0) throws SQLException {
0787: throw new UnsupportedOperationException();
0788: }
0789:
0790: /* (non-Javadoc)
0791: * @see java.sql.ResultSet#getBigDecimal(java.lang.String)
0792: */
0793: public BigDecimal getBigDecimal(String arg0) throws SQLException {
0794: throw new UnsupportedOperationException();
0795: }
0796:
0797: /* (non-Javadoc)
0798: * @see java.sql.ResultSet#isBeforeFirst()
0799: */
0800: public boolean isBeforeFirst() throws SQLException {
0801: throw new UnsupportedOperationException();
0802: }
0803:
0804: /* (non-Javadoc)
0805: * @see java.sql.ResultSet#isAfterLast()
0806: */
0807: public boolean isAfterLast() throws SQLException {
0808: throw new UnsupportedOperationException();
0809: }
0810:
0811: /* (non-Javadoc)
0812: * @see java.sql.ResultSet#isFirst()
0813: */
0814: public boolean isFirst() throws SQLException {
0815: throw new UnsupportedOperationException();
0816: }
0817:
0818: /* (non-Javadoc)
0819: * @see java.sql.ResultSet#isLast()
0820: */
0821: public boolean isLast() throws SQLException {
0822: throw new UnsupportedOperationException();
0823: }
0824:
0825: /* (non-Javadoc)
0826: * @see java.sql.ResultSet#beforeFirst()
0827: */
0828: public void beforeFirst() throws SQLException {
0829: throw new UnsupportedOperationException();
0830: }
0831:
0832: /* (non-Javadoc)
0833: * @see java.sql.ResultSet#afterLast()
0834: */
0835: public void afterLast() throws SQLException {
0836: throw new UnsupportedOperationException();
0837: }
0838:
0839: /* (non-Javadoc)
0840: * @see java.sql.ResultSet#first()
0841: */
0842: public boolean first() throws SQLException {
0843: throw new UnsupportedOperationException();
0844: }
0845:
0846: /* (non-Javadoc)
0847: * @see java.sql.ResultSet#last()
0848: */
0849: public boolean last() throws SQLException {
0850: throw new UnsupportedOperationException();
0851: }
0852:
0853: /* (non-Javadoc)
0854: * @see java.sql.ResultSet#getRow()
0855: */
0856: public int getRow() throws SQLException {
0857: throw new UnsupportedOperationException();
0858: }
0859:
0860: /* (non-Javadoc)
0861: * @see java.sql.ResultSet#absolute(int)
0862: */
0863: public boolean absolute(int arg0) throws SQLException {
0864: throw new UnsupportedOperationException();
0865: }
0866:
0867: /* (non-Javadoc)
0868: * @see java.sql.ResultSet#relative(int)
0869: */
0870: public boolean relative(int arg0) throws SQLException {
0871: throw new UnsupportedOperationException();
0872: }
0873:
0874: /* (non-Javadoc)
0875: * @see java.sql.ResultSet#setFetchDirection(int)
0876: */
0877: public void setFetchDirection(int arg0) throws SQLException {
0878: throw new UnsupportedOperationException();
0879: }
0880:
0881: /* (non-Javadoc)
0882: * @see java.sql.ResultSet#getFetchDirection()
0883: */
0884: public int getFetchDirection() throws SQLException {
0885: throw new UnsupportedOperationException();
0886: }
0887:
0888: /* (non-Javadoc)
0889: * @see java.sql.ResultSet#setFetchSize(int)
0890: */
0891: public void setFetchSize(int arg0) throws SQLException {
0892: throw new UnsupportedOperationException();
0893: }
0894:
0895: /* (non-Javadoc)
0896: * @see java.sql.ResultSet#getFetchSize()
0897: */
0898: public int getFetchSize() throws SQLException {
0899: throw new UnsupportedOperationException();
0900: }
0901:
0902: /* (non-Javadoc)
0903: * @see java.sql.ResultSet#getType()
0904: */
0905: public int getType() throws SQLException {
0906: throw new UnsupportedOperationException();
0907: }
0908:
0909: /* (non-Javadoc)
0910: * @see java.sql.ResultSet#getConcurrency()
0911: */
0912: public int getConcurrency() throws SQLException {
0913: throw new UnsupportedOperationException();
0914: }
0915:
0916: /* (non-Javadoc)
0917: * @see java.sql.ResultSet#rowUpdated()
0918: */
0919: public boolean rowUpdated() throws SQLException {
0920: throw new UnsupportedOperationException();
0921: }
0922:
0923: /* (non-Javadoc)
0924: * @see java.sql.ResultSet#rowInserted()
0925: */
0926: public boolean rowInserted() throws SQLException {
0927: throw new UnsupportedOperationException();
0928: }
0929:
0930: /* (non-Javadoc)
0931: * @see java.sql.ResultSet#rowDeleted()
0932: */
0933: public boolean rowDeleted() throws SQLException {
0934: throw new UnsupportedOperationException();
0935: }
0936:
0937: /* (non-Javadoc)
0938: * @see java.sql.ResultSet#updateNull(int)
0939: */
0940: public void updateNull(int arg0) throws SQLException {
0941: throw new UnsupportedOperationException();
0942: }
0943:
0944: /* (non-Javadoc)
0945: * @see java.sql.ResultSet#updateBoolean(int, boolean)
0946: */
0947: public void updateBoolean(int arg0, boolean arg1)
0948: throws SQLException {
0949: throw new UnsupportedOperationException();
0950: }
0951:
0952: /* (non-Javadoc)
0953: * @see java.sql.ResultSet#updateByte(int, byte)
0954: */
0955: public void updateByte(int arg0, byte arg1) throws SQLException {
0956: throw new UnsupportedOperationException();
0957: }
0958:
0959: /* (non-Javadoc)
0960: * @see java.sql.ResultSet#updateShort(int, short)
0961: */
0962: public void updateShort(int arg0, short arg1) throws SQLException {
0963: throw new UnsupportedOperationException();
0964: }
0965:
0966: /* (non-Javadoc)
0967: * @see java.sql.ResultSet#updateInt(int, int)
0968: */
0969: public void updateInt(int arg0, int arg1) throws SQLException {
0970: throw new UnsupportedOperationException();
0971: }
0972:
0973: /* (non-Javadoc)
0974: * @see java.sql.ResultSet#updateLong(int, long)
0975: */
0976: public void updateLong(int arg0, long arg1) throws SQLException {
0977: throw new UnsupportedOperationException();
0978: }
0979:
0980: /* (non-Javadoc)
0981: * @see java.sql.ResultSet#updateFloat(int, float)
0982: */
0983: public void updateFloat(int arg0, float arg1) throws SQLException {
0984: throw new UnsupportedOperationException();
0985: }
0986:
0987: /* (non-Javadoc)
0988: * @see java.sql.ResultSet#updateDouble(int, double)
0989: */
0990: public void updateDouble(int arg0, double arg1) throws SQLException {
0991: throw new UnsupportedOperationException();
0992: }
0993:
0994: /* (non-Javadoc)
0995: * @see java.sql.ResultSet#updateBigDecimal(int, java.math.BigDecimal)
0996: */
0997: public void updateBigDecimal(int arg0, BigDecimal arg1)
0998: throws SQLException {
0999: throw new UnsupportedOperationException();
1000: }
1001:
1002: /* (non-Javadoc)
1003: * @see java.sql.ResultSet#updateString(int, java.lang.String)
1004: */
1005: public void updateString(int arg0, String arg1) throws SQLException {
1006: throw new UnsupportedOperationException();
1007: }
1008:
1009: /* (non-Javadoc)
1010: * @see java.sql.ResultSet#updateBytes(int, byte[])
1011: */
1012: public void updateBytes(int arg0, byte[] arg1) throws SQLException {
1013: throw new UnsupportedOperationException();
1014: }
1015:
1016: /* (non-Javadoc)
1017: * @see java.sql.ResultSet#updateDate(int, java.sql.Date)
1018: */
1019: public void updateDate(int arg0, Date arg1) throws SQLException {
1020: throw new UnsupportedOperationException();
1021: }
1022:
1023: /* (non-Javadoc)
1024: * @see java.sql.ResultSet#updateTime(int, java.sql.Time)
1025: */
1026: public void updateTime(int arg0, Time arg1) throws SQLException {
1027: throw new UnsupportedOperationException();
1028: }
1029:
1030: /* (non-Javadoc)
1031: * @see java.sql.ResultSet#updateTimestamp(int, java.sql.Timestamp)
1032: */
1033: public void updateTimestamp(int arg0, Timestamp arg1)
1034: throws SQLException {
1035: throw new UnsupportedOperationException();
1036: }
1037:
1038: /* (non-Javadoc)
1039: * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, int)
1040: */
1041: public void updateAsciiStream(int arg0, InputStream arg1, int arg2)
1042: throws SQLException {
1043: throw new UnsupportedOperationException();
1044: }
1045:
1046: /* (non-Javadoc)
1047: * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, int)
1048: */
1049: public void updateBinaryStream(int arg0, InputStream arg1, int arg2)
1050: throws SQLException {
1051: throw new UnsupportedOperationException();
1052: }
1053:
1054: /* (non-Javadoc)
1055: * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, int)
1056: */
1057: public void updateCharacterStream(int arg0, Reader arg1, int arg2)
1058: throws SQLException {
1059: throw new UnsupportedOperationException();
1060: }
1061:
1062: /* (non-Javadoc)
1063: * @see java.sql.ResultSet#updateObject(int, java.lang.Object, int)
1064: */
1065: public void updateObject(int arg0, Object arg1, int arg2)
1066: throws SQLException {
1067: throw new UnsupportedOperationException();
1068: }
1069:
1070: /* (non-Javadoc)
1071: * @see java.sql.ResultSet#updateObject(int, java.lang.Object)
1072: */
1073: public void updateObject(int arg0, Object arg1) throws SQLException {
1074: throw new UnsupportedOperationException();
1075: }
1076:
1077: /* (non-Javadoc)
1078: * @see java.sql.ResultSet#updateNull(java.lang.String)
1079: */
1080: public void updateNull(String arg0) throws SQLException {
1081: throw new UnsupportedOperationException();
1082: }
1083:
1084: /* (non-Javadoc)
1085: * @see java.sql.ResultSet#updateBoolean(java.lang.String, boolean)
1086: */
1087: public void updateBoolean(String arg0, boolean arg1)
1088: throws SQLException {
1089: throw new UnsupportedOperationException();
1090: }
1091:
1092: /* (non-Javadoc)
1093: * @see java.sql.ResultSet#updateByte(java.lang.String, byte)
1094: */
1095: public void updateByte(String arg0, byte arg1) throws SQLException {
1096: throw new UnsupportedOperationException();
1097: }
1098:
1099: /* (non-Javadoc)
1100: * @see java.sql.ResultSet#updateShort(java.lang.String, short)
1101: */
1102: public void updateShort(String arg0, short arg1)
1103: throws SQLException {
1104: throw new UnsupportedOperationException();
1105: }
1106:
1107: /* (non-Javadoc)
1108: * @see java.sql.ResultSet#updateInt(java.lang.String, int)
1109: */
1110: public void updateInt(String arg0, int arg1) throws SQLException {
1111: throw new UnsupportedOperationException();
1112: }
1113:
1114: /* (non-Javadoc)
1115: * @see java.sql.ResultSet#updateLong(java.lang.String, long)
1116: */
1117: public void updateLong(String arg0, long arg1) throws SQLException {
1118: throw new UnsupportedOperationException();
1119: }
1120:
1121: /* (non-Javadoc)
1122: * @see java.sql.ResultSet#updateFloat(java.lang.String, float)
1123: */
1124: public void updateFloat(String arg0, float arg1)
1125: throws SQLException {
1126: throw new UnsupportedOperationException();
1127: }
1128:
1129: /* (non-Javadoc)
1130: * @see java.sql.ResultSet#updateDouble(java.lang.String, double)
1131: */
1132: public void updateDouble(String arg0, double arg1)
1133: throws SQLException {
1134: throw new UnsupportedOperationException();
1135: }
1136:
1137: /* (non-Javadoc)
1138: * @see java.sql.ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal)
1139: */
1140: public void updateBigDecimal(String arg0, BigDecimal arg1)
1141: throws SQLException {
1142: throw new UnsupportedOperationException();
1143: }
1144:
1145: /* (non-Javadoc)
1146: * @see java.sql.ResultSet#updateString(java.lang.String, java.lang.String)
1147: */
1148: public void updateString(String arg0, String arg1)
1149: throws SQLException {
1150: throw new UnsupportedOperationException();
1151: }
1152:
1153: /* (non-Javadoc)
1154: * @see java.sql.ResultSet#updateBytes(java.lang.String, byte[])
1155: */
1156: public void updateBytes(String arg0, byte[] arg1)
1157: throws SQLException {
1158: throw new UnsupportedOperationException();
1159: }
1160:
1161: /* (non-Javadoc)
1162: * @see java.sql.ResultSet#updateDate(java.lang.String, java.sql.Date)
1163: */
1164: public void updateDate(String arg0, Date arg1) throws SQLException {
1165: throw new UnsupportedOperationException();
1166: }
1167:
1168: /* (non-Javadoc)
1169: * @see java.sql.ResultSet#updateTime(java.lang.String, java.sql.Time)
1170: */
1171: public void updateTime(String arg0, Time arg1) throws SQLException {
1172: throw new UnsupportedOperationException();
1173: }
1174:
1175: /* (non-Javadoc)
1176: * @see java.sql.ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp)
1177: */
1178: public void updateTimestamp(String arg0, Timestamp arg1)
1179: throws SQLException {
1180: throw new UnsupportedOperationException();
1181: }
1182:
1183: /* (non-Javadoc)
1184: * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, int)
1185: */
1186: public void updateAsciiStream(String arg0, InputStream arg1,
1187: int arg2) throws SQLException {
1188: throw new UnsupportedOperationException();
1189: }
1190:
1191: /* (non-Javadoc)
1192: * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, int)
1193: */
1194: public void updateBinaryStream(String arg0, InputStream arg1,
1195: int arg2) throws SQLException {
1196: throw new UnsupportedOperationException();
1197: }
1198:
1199: /* (non-Javadoc)
1200: * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, int)
1201: */
1202: public void updateCharacterStream(String arg0, Reader arg1, int arg2)
1203: throws SQLException {
1204: throw new UnsupportedOperationException();
1205: }
1206:
1207: /* (non-Javadoc)
1208: * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object, int)
1209: */
1210: public void updateObject(String arg0, Object arg1, int arg2)
1211: throws SQLException {
1212: throw new UnsupportedOperationException();
1213: }
1214:
1215: /* (non-Javadoc)
1216: * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object)
1217: */
1218: public void updateObject(String arg0, Object arg1)
1219: throws SQLException {
1220: throw new UnsupportedOperationException();
1221: }
1222:
1223: /* (non-Javadoc)
1224: * @see java.sql.ResultSet#insertRow()
1225: */
1226: public void insertRow() throws SQLException {
1227: throw new UnsupportedOperationException();
1228: }
1229:
1230: /* (non-Javadoc)
1231: * @see java.sql.ResultSet#updateRow()
1232: */
1233: public void updateRow() throws SQLException {
1234: throw new UnsupportedOperationException();
1235: }
1236:
1237: /* (non-Javadoc)
1238: * @see java.sql.ResultSet#deleteRow()
1239: */
1240: public void deleteRow() throws SQLException {
1241: throw new UnsupportedOperationException();
1242: }
1243:
1244: /* (non-Javadoc)
1245: * @see java.sql.ResultSet#refreshRow()
1246: */
1247: public void refreshRow() throws SQLException {
1248: throw new UnsupportedOperationException();
1249: }
1250:
1251: /* (non-Javadoc)
1252: * @see java.sql.ResultSet#cancelRowUpdates()
1253: */
1254: public void cancelRowUpdates() throws SQLException {
1255: throw new UnsupportedOperationException();
1256: }
1257:
1258: /* (non-Javadoc)
1259: * @see java.sql.ResultSet#moveToInsertRow()
1260: */
1261: public void moveToInsertRow() throws SQLException {
1262: throw new UnsupportedOperationException();
1263: }
1264:
1265: /* (non-Javadoc)
1266: * @see java.sql.ResultSet#moveToCurrentRow()
1267: */
1268: public void moveToCurrentRow() throws SQLException {
1269: throw new UnsupportedOperationException();
1270: }
1271:
1272: /* (non-Javadoc)
1273: * @see java.sql.ResultSet#getStatement()
1274: */
1275: public Statement getStatement() throws SQLException {
1276: throw new UnsupportedOperationException();
1277: }
1278:
1279: /* (non-Javadoc)
1280: * @see java.sql.ResultSet#getObject(int, java.util.Map)
1281: */
1282: public Object getObject(int arg0, Map arg1) throws SQLException {
1283: throw new UnsupportedOperationException();
1284: }
1285:
1286: /* (non-Javadoc)
1287: * @see java.sql.ResultSet#getRef(int)
1288: */
1289: public Ref getRef(int arg0) throws SQLException {
1290: throw new UnsupportedOperationException();
1291: }
1292:
1293: /* (non-Javadoc)
1294: * @see java.sql.ResultSet#getBlob(int)
1295: */
1296: public Blob getBlob(int arg0) throws SQLException {
1297: throw new UnsupportedOperationException();
1298: }
1299:
1300: /* (non-Javadoc)
1301: * @see java.sql.ResultSet#getClob(int)
1302: */
1303: public Clob getClob(int arg0) throws SQLException {
1304: throw new UnsupportedOperationException();
1305: }
1306:
1307: /* (non-Javadoc)
1308: * @see java.sql.ResultSet#getArray(int)
1309: */
1310: public Array getArray(int arg0) throws SQLException {
1311: throw new UnsupportedOperationException();
1312: }
1313:
1314: /* (non-Javadoc)
1315: * @see java.sql.ResultSet#getObject(java.lang.String, java.util.Map)
1316: */
1317: public Object getObject(String arg0, Map arg1) throws SQLException {
1318: throw new UnsupportedOperationException();
1319: }
1320:
1321: /* (non-Javadoc)
1322: * @see java.sql.ResultSet#getRef(java.lang.String)
1323: */
1324: public Ref getRef(String arg0) throws SQLException {
1325: throw new UnsupportedOperationException();
1326: }
1327:
1328: /* (non-Javadoc)
1329: * @see java.sql.ResultSet#getBlob(java.lang.String)
1330: */
1331: public Blob getBlob(String arg0) throws SQLException {
1332: throw new UnsupportedOperationException();
1333: }
1334:
1335: /* (non-Javadoc)
1336: * @see java.sql.ResultSet#getClob(java.lang.String)
1337: */
1338: public Clob getClob(String arg0) throws SQLException {
1339: throw new UnsupportedOperationException();
1340: }
1341:
1342: /* (non-Javadoc)
1343: * @see java.sql.ResultSet#getArray(java.lang.String)
1344: */
1345: public Array getArray(String arg0) throws SQLException {
1346: throw new UnsupportedOperationException();
1347: }
1348:
1349: /* (non-Javadoc)
1350: * @see java.sql.ResultSet#getDate(int, java.util.Calendar)
1351: */
1352: public Date getDate(int arg0, Calendar arg1) throws SQLException {
1353: throw new UnsupportedOperationException();
1354: }
1355:
1356: /* (non-Javadoc)
1357: * @see java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar)
1358: */
1359: public Date getDate(String arg0, Calendar arg1) throws SQLException {
1360: throw new UnsupportedOperationException();
1361: }
1362:
1363: /* (non-Javadoc)
1364: * @see java.sql.ResultSet#getTime(int, java.util.Calendar)
1365: */
1366: public Time getTime(int arg0, Calendar arg1) throws SQLException {
1367: throw new UnsupportedOperationException();
1368: }
1369:
1370: /* (non-Javadoc)
1371: * @see java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar)
1372: */
1373: public Time getTime(String arg0, Calendar arg1) throws SQLException {
1374: throw new UnsupportedOperationException();
1375: }
1376:
1377: /* (non-Javadoc)
1378: * @see java.sql.ResultSet#getTimestamp(int, java.util.Calendar)
1379: */
1380: public Timestamp getTimestamp(int arg0, Calendar arg1)
1381: throws SQLException {
1382: throw new UnsupportedOperationException();
1383: }
1384:
1385: /* (non-Javadoc)
1386: * @see java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar)
1387: */
1388: public Timestamp getTimestamp(String arg0, Calendar arg1)
1389: throws SQLException {
1390: throw new UnsupportedOperationException();
1391: }
1392:
1393: /* (non-Javadoc)
1394: * @see java.sql.ResultSet#getURL(int)
1395: */
1396: public URL getURL(int arg0) throws SQLException {
1397: throw new UnsupportedOperationException();
1398: }
1399:
1400: /* (non-Javadoc)
1401: * @see java.sql.ResultSet#getURL(java.lang.String)
1402: */
1403: public URL getURL(String arg0) throws SQLException {
1404: throw new UnsupportedOperationException();
1405: }
1406:
1407: /* (non-Javadoc)
1408: * @see java.sql.ResultSet#updateRef(int, java.sql.Ref)
1409: */
1410: public void updateRef(int arg0, Ref arg1) throws SQLException {
1411: throw new UnsupportedOperationException();
1412: }
1413:
1414: /* (non-Javadoc)
1415: * @see java.sql.ResultSet#updateRef(java.lang.String, java.sql.Ref)
1416: */
1417: public void updateRef(String arg0, Ref arg1) throws SQLException {
1418: throw new UnsupportedOperationException();
1419: }
1420:
1421: /* (non-Javadoc)
1422: * @see java.sql.ResultSet#updateBlob(int, java.sql.Blob)
1423: */
1424: public void updateBlob(int arg0, Blob arg1) throws SQLException {
1425: throw new UnsupportedOperationException();
1426: }
1427:
1428: /* (non-Javadoc)
1429: * @see java.sql.ResultSet#updateBlob(java.lang.String, java.sql.Blob)
1430: */
1431: public void updateBlob(String arg0, Blob arg1) throws SQLException {
1432: throw new UnsupportedOperationException();
1433: }
1434:
1435: /* (non-Javadoc)
1436: * @see java.sql.ResultSet#updateClob(int, java.sql.Clob)
1437: */
1438: public void updateClob(int arg0, Clob arg1) throws SQLException {
1439: throw new UnsupportedOperationException();
1440: }
1441:
1442: /* (non-Javadoc)
1443: * @see java.sql.ResultSet#updateClob(java.lang.String, java.sql.Clob)
1444: */
1445: public void updateClob(String arg0, Clob arg1) throws SQLException {
1446: throw new UnsupportedOperationException();
1447: }
1448:
1449: /* (non-Javadoc)
1450: * @see java.sql.ResultSet#updateArray(int, java.sql.Array)
1451: */
1452: public void updateArray(int arg0, Array arg1) throws SQLException {
1453: throw new UnsupportedOperationException();
1454: }
1455:
1456: /* (non-Javadoc)
1457: * @see java.sql.ResultSet#updateArray(java.lang.String, java.sql.Array)
1458: */
1459: public void updateArray(String arg0, Array arg1)
1460: throws SQLException {
1461: throw new UnsupportedOperationException();
1462: }
1463: }
|