0001: /*
0002: Copyright (C) 2003 Together
0003:
0004: This library is free software; you can redistribute it and/or
0005: modify it under the terms of the GNU Lesser General Public
0006: License as published by the Free Software Foundation; either
0007: version 2.1 of the License, or (at your option) any later version.
0008:
0009: This library is distributed in the hope that it will be useful,
0010: but WITHOUT ANY WARRANTY; without even the implied warranty of
0011: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0012: Lesser General Public License for more details.
0013:
0014: You should have received a copy of the GNU Lesser General Public
0015: License along with this library; if not, write to the Free Software
0016: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0017: */
0018:
0019: package org.webdocwf.util.xml;
0020:
0021: import java.io.ByteArrayInputStream;
0022: import java.io.IOException;
0023: import java.io.InputStream;
0024: import java.io.Reader;
0025: import java.io.StringReader;
0026: import java.math.BigDecimal;
0027: import java.net.URL;
0028: import java.sql.*;
0029: import java.util.ArrayList;
0030: import java.util.Map;
0031: import java.util.Calendar;
0032:
0033: /**
0034: * Class that implements JDBC ResultSet interface.
0035: *
0036: * @author Zoran Milakovic
0037: */
0038: public class XmlResultSet implements ResultSet {
0039:
0040: /** Metadata for this ResultSet */
0041: protected ResultSetMetaData resultSetMetaData;
0042:
0043: /** Statement that produced this ResultSet */
0044: protected Statement statement;
0045:
0046: /** Helper class that performs the actual file reads */
0047: protected XmlReader reader;
0048:
0049: /** Table referenced by the Statement */
0050: protected String tableName;
0051:
0052: /** Array of available columns for referenced table */
0053: protected String[] columnNames;
0054:
0055: /** Array of column values for referenced table */
0056: protected String[] columnValues;
0057:
0058: protected String[] whereColumnNames;
0059:
0060: protected String[] whereColumnValues;
0061:
0062: /** Last column name index read */
0063: protected int lastIndexRead = -1;
0064:
0065: /** InputStream to keep track of */
0066: protected InputStream is;
0067:
0068: /**
0069: * Constructor for the XmlResultSet object
0070: *
0071: * @param statement Statement that produced this ResultSet
0072: * @param reader Helper class that performs the actual file reads
0073: * @param tableName Table referenced by the Statement
0074: * @param columnNames Array of available columns for referenced table
0075: * @param whereColumnNames is an array of column names
0076: * @param whereColumnValues is an array of column values
0077: */
0078: protected XmlResultSet(Statement statement, XmlReader reader,
0079: String tableName, String[] columnNames,
0080: String[] whereColumnNames, String[] whereColumnValues) {
0081: this .statement = statement;
0082: this .reader = reader;
0083: this .tableName = tableName;
0084: this .columnNames = columnNames;
0085: this .whereColumnNames = whereColumnNames;
0086: this .whereColumnValues = whereColumnValues;
0087: }
0088:
0089: public void select() throws SQLException {
0090: reader.select(tableName, columnNames, whereColumnNames,
0091: whereColumnValues);
0092: this .rset = reader.getResultSet();
0093: }
0094:
0095: public void selectTableNames() throws SQLException {
0096: reader.selectTableNames();
0097: this .rset = reader.getResultSet();
0098: }
0099:
0100: public void close() {
0101: }
0102:
0103: private int index = 0;
0104: private ArrayList rset = new ArrayList();
0105:
0106: /**
0107: *Description of the Method
0108: *
0109: * @return Description of the Returned Value
0110: * @exception SQLException
0111: * @since
0112: */
0113: public boolean next() throws SQLException {
0114: boolean retVal = false;
0115: try {
0116: if (!(rset.size() <= index)) {
0117: this .columnValues = (String[]) rset.get(index);
0118: index++;
0119: retVal = true;
0120: } else {
0121: index = 0;
0122: rset = new ArrayList();
0123: this .columnValues = new String[0];
0124: retVal = false;
0125: }
0126: } catch (Exception e) {
0127: throw new SQLException("Error in ResultSet.next() : "
0128: + e.getMessage());
0129: }
0130: return retVal;
0131: }
0132:
0133: public String getString(int i) throws SQLException {
0134: try {
0135: lastIndexRead = i;
0136: return this .columnValues[i - 1].toString();
0137: } catch (Exception e) {
0138: throw new SQLException(
0139: "Error ResultSet.getString( index ) : "
0140: + e.getMessage());
0141: }
0142: }
0143:
0144: /**
0145: * Reports whether
0146: * the last column read had a value of SQL <code>NULL</code>.
0147: * Note that you must first call one of the getter methods
0148: * on a column to try to read its value and then call
0149: * the method <code>wasNull</code> to see if the value read was
0150: * SQL <code>NULL</code>.
0151: *
0152: * @return <code>true</code> if the last column value read was SQL
0153: * <code>NULL</code> and <code>false</code> otherwise
0154: * @exception SQLException if a database access error occurs
0155: */
0156: public boolean wasNull() throws SQLException {
0157: if (lastIndexRead >= 0) {
0158: return (getString(lastIndexRead) == null)
0159: || (getString(lastIndexRead) == "null");
0160: } else {
0161: throw new SQLException("No previous getter method called");
0162: }
0163: }
0164:
0165: //======================================================================
0166: // Methods for accessing results by column index
0167: //======================================================================
0168:
0169: /**
0170: * Retrieves the value of the designated column in the current row
0171: * of this <code>ResultSet</code> object as
0172: * a <code>boolean</code> in the Java programming language.
0173: *
0174: * @param columnIndex the first column is 1, the second is 2, ...
0175: * @return the column value; if the value is SQL <code>NULL</code>, the
0176: * value returned is <code>false</code>
0177: * @exception SQLException if a database access error occurs
0178: */
0179: public boolean getBoolean(int columnIndex) throws SQLException {
0180: String str = getString(columnIndex);
0181: return (str == null) ? false : Boolean.valueOf(str)
0182: .booleanValue();
0183: }
0184:
0185: /**
0186: * Retrieves the value of the designated column in the current row
0187: * of this <code>ResultSet</code> object as
0188: * a <code>byte</code> in the Java programming language.
0189: *
0190: * @param columnIndex the first column is 1, the second is 2, ...
0191: * @return the column value; if the value is SQL <code>NULL</code>, the
0192: * value returned is <code>0</code>
0193: * @exception SQLException if a database access error occurs
0194: */
0195: public byte getByte(int columnIndex) throws SQLException {
0196: String str = getString(columnIndex);
0197: return (str == null) ? 0 : Byte.parseByte(str);
0198: }
0199:
0200: /**
0201: * Retrieves the value of the designated column in the current row
0202: * of this <code>ResultSet</code> object as
0203: * a <code>short</code> in the Java programming language.
0204: *
0205: * @param columnIndex the first column is 1, the second is 2, ...
0206: * @return the column value; if the value is SQL <code>NULL</code>, the
0207: * value returned is <code>0</code>
0208: * @exception SQLException if a database access error occurs
0209: */
0210: public short getShort(int columnIndex) throws SQLException {
0211: String str = getString(columnIndex);
0212: return (str == null) ? 0 : Short.parseShort(str);
0213: }
0214:
0215: /**
0216: * Gets the value of the designated column in the current row
0217: * of this <code>ResultSet</code> object as
0218: * an <code>int</code> in the Java programming language.
0219: *
0220: * @param columnIndex the first column is 1, the second is 2, ...
0221: * @return the column value; if the value is SQL <code>NULL</code>, the
0222: * value returned is <code>0</code>
0223: * @exception SQLException if a database access error occurs
0224: */
0225: public int getInt(int columnIndex) throws SQLException {
0226: String str = getString(columnIndex);
0227: return (str == null) ? 0 : Integer.parseInt(str);
0228: }
0229:
0230: /**
0231: * Retrieves the value of the designated column in the current row
0232: * of this <code>ResultSet</code> object as
0233: * a <code>long</code> in the Java programming language.
0234: *
0235: * @param columnIndex the first column is 1, the second is 2, ...
0236: * @return the column value; if the value is SQL <code>NULL</code>, the
0237: * value returned is <code>0</code>
0238: * @exception SQLException if a database access error occurs
0239: */
0240: public long getLong(int columnIndex) throws SQLException {
0241: String str = getString(columnIndex);
0242: return (str == null) ? 0L : Long.parseLong(str);
0243: }
0244:
0245: /**
0246: * Gets the value of the designated column in the current row
0247: * of this <code>ResultSet</code> object as
0248: * a <code>float</code> in the Java programming language.
0249: *
0250: * @param columnIndex the first column is 1, the second is 2, ...
0251: * @return the column value; if the value is SQL <code>NULL</code>, the
0252: * value returned is <code>0</code>
0253: * @exception SQLException if a database access error occurs
0254: */
0255: public float getFloat(int columnIndex) throws SQLException {
0256: String str = getString(columnIndex);
0257: return (str == null) ? 0F : Float.parseFloat(str);
0258: }
0259:
0260: /**
0261: * Retrieves the value of the designated column in the current row
0262: * of this <code>ResultSet</code> object as
0263: * a <code>double</code> in the Java programming language.
0264: *
0265: * @param columnIndex the first column is 1, the second is 2, ...
0266: * @return the column value; if the value is SQL <code>NULL</code>, the
0267: * value returned is <code>0</code>
0268: * @exception SQLException if a database access error occurs
0269: */
0270: public double getDouble(int columnIndex) throws SQLException {
0271: String str = getString(columnIndex);
0272: return (str == null) ? 0D : Double.parseDouble(str);
0273: }
0274:
0275: /**
0276: * Retrieves the value of the designated column in the current row
0277: * of this <code>ResultSet</code> object as
0278: * a <code>java.sql.BigDecimal</code> in the Java programming language.
0279: *
0280: * @param columnIndex the first column is 1, the second is 2, ...
0281: * @param scale the number of digits to the right of the decimal point
0282: * @return the column value; if the value is SQL <code>NULL</code>, the
0283: * value returned is <code>null</code>
0284: * @exception SQLException if a database access error occurs
0285: * @deprecated
0286: */
0287: public BigDecimal getBigDecimal(int columnIndex, int scale)
0288: throws SQLException {
0289: // let getBigDecimal(int) handle this for now
0290: return getBigDecimal(columnIndex);
0291: }
0292:
0293: /**
0294: * Retrieves the value of the designated column in the current row
0295: * of this <code>ResultSet</code> object as
0296: * a <code>byte</code> array in the Java programming language.
0297: * The bytes represent the raw values returned by the driver.
0298: *
0299: * @param columnIndex the first column is 1, the second is 2, ...
0300: * @return the column value; if the value is SQL <code>NULL</code>, the
0301: * value returned is <code>null</code>
0302: * @exception SQLException if a database access error occurs
0303: */
0304: public byte[] getBytes(int columnIndex) throws SQLException {
0305: String str = getString(columnIndex);
0306: return (str == null) ? null : Utils.hexStringToBytes(str);
0307: }
0308:
0309: /**
0310: * Retrieves the value of the designated column in the current row
0311: * of this <code>ResultSet</code> object as
0312: * a <code>java.sql.Date</code> object in the Java programming language.
0313: *
0314: * @param columnIndex the first column is 1, the second is 2, ...
0315: * @return the column value; if the value is SQL <code>NULL</code>, the
0316: * value returned is <code>null</code>
0317: * @exception SQLException if a database access error occurs
0318: */
0319: public Date getDate(int columnIndex) throws SQLException {
0320: String str = getString(columnIndex);
0321: return (str == null) ? null : Date.valueOf(str);
0322: }
0323:
0324: /**
0325: * Retrieves the value of the designated column in the current row
0326: * of this <code>ResultSet</code> object as
0327: * a <code>java.sql.Time</code> object in the Java programming language.
0328: *
0329: * @param columnIndex the first column is 1, the second is 2, ...
0330: * @return the column value; if the value is SQL <code>NULL</code>, the
0331: * value returned is <code>null</code>
0332: * @exception SQLException if a database access error occurs
0333: */
0334: public Time getTime(int columnIndex) throws SQLException {
0335: String str = getString(columnIndex);
0336: return (str == null) ? null : Time.valueOf(str);
0337: }
0338:
0339: /**
0340: * Retrieves the value of the designated column in the current row
0341: * of this <code>ResultSet</code> object as a
0342: * <code>java.sql.Timestamp</code> object in the Java programming language.
0343: *
0344: * @param columnIndex the first column is 1, the second is 2, ...
0345: * @return the column value; if the value is SQL <code>NULL</code>, the
0346: * value returned is <code>null</code>
0347: * @exception SQLException if a database access error occurs
0348: */
0349: public Timestamp getTimestamp(int columnIndex) throws SQLException {
0350: String str = getString(columnIndex);
0351: return (str == null) ? null : Timestamp.valueOf(str);
0352: }
0353:
0354: /**
0355: * Retrieves the value of the designated column in the current row
0356: * of this <code>ResultSet</code> object as a stream of ASCII characters.
0357: * The value can then be read in chunks from the stream. This method is
0358: * particularly suitable for retrieving large <char>LONGVARCHAR</char>
0359: * values. The JDBC driver will do any necessary conversion from the
0360: * database format into ASCII.
0361: *
0362: * <P><B>Note:</B> All the data in the returned stream must be
0363: * read prior to getting the value of any other column. The next
0364: * call to a getter method implicitly closes the stream. Also, a
0365: * stream may return <code>0</code> when the method
0366: * <code>InputStream.available</code>
0367: * is called whether there is data available or not.
0368: *
0369: * @param columnIndex the first column is 1, the second is 2, ...
0370: * @return a Java input stream that delivers the database column value
0371: * as a stream of one-byte ASCII characters;
0372: * if the value is SQL <code>NULL</code>, the
0373: * value returned is <code>null</code>
0374: * @exception SQLException if a database access error occurs
0375: */
0376: public InputStream getAsciiStream(int columnIndex)
0377: throws SQLException {
0378: String str = getString(columnIndex);
0379: is = new ByteArrayInputStream(str.getBytes());
0380: return (str == null) ? null : is;
0381: }
0382:
0383: /**
0384: * Retrieves the value of the designated column in the current row
0385: * of this <code>ResultSet</code> object as
0386: * as a stream of two-byte Unicode characters. The first byte is
0387: * the high byte; the second byte is the low byte.
0388: *
0389: * The value can then be read in chunks from the
0390: * stream. This method is particularly
0391: * suitable for retrieving large <code>LONGVARCHAR</code>values. The
0392: * JDBC driver will do any necessary conversion from the database
0393: * format into Unicode.
0394: *
0395: * <P><B>Note:</B> All the data in the returned stream must be
0396: * read prior to getting the value of any other column. The next
0397: * call to a getter method implicitly closes the stream.
0398: * Also, a stream may return <code>0</code> when the method
0399: * <code>InputStream.available</code>
0400: * is called, whether there is data available or not.
0401: *
0402: * @param columnIndex the first column is 1, the second is 2, ...
0403: * @return a Java input stream that delivers the database column value
0404: * as a stream of two-byte Unicode characters;
0405: * if the value is SQL <code>NULL</code>, the value returned is
0406: * <code>null</code>
0407: *
0408: * @exception SQLException if a database access error occurs
0409: * @deprecated use <code>getCharacterStream</code> in place of
0410: * <code>getUnicodeStream</code>
0411: */
0412: public InputStream getUnicodeStream(int columnIndex)
0413: throws SQLException {
0414: // delegate to getAsciiStream(int)
0415: return getAsciiStream(columnIndex);
0416: }
0417:
0418: /**
0419: * Retrieves the value of the designated column in the current row
0420: * of this <code>ResultSet</code> object as a binary stream of
0421: * uninterpreted bytes. The value can then be read in chunks from the
0422: * stream. This method is particularly
0423: * suitable for retrieving large <code>LONGVARBINARY</code> values.
0424: *
0425: * <P><B>Note:</B> All the data in the returned stream must be
0426: * read prior to getting the value of any other column. The next
0427: * call to a getter method implicitly closes the stream. Also, a
0428: * stream may return <code>0</code> when the method
0429: * <code>InputStream.available</code>
0430: * is called whether there is data available or not.
0431: *
0432: * @param columnIndex the first column is 1, the second is 2, ...
0433: * @return a Java input stream that delivers the database column value
0434: * as a stream of uninterpreted bytes;
0435: * if the value is SQL <code>NULL</code>, the value returned is
0436: * <code>null</code>
0437: * @exception SQLException if a database access error occurs
0438: */
0439: public InputStream getBinaryStream(int columnIndex)
0440: throws SQLException {
0441: // delegate to getAsciiStream(int)
0442: return getAsciiStream(columnIndex);
0443: }
0444:
0445: //======================================================================
0446: // Methods for accessing results by column name
0447: //======================================================================
0448:
0449: /**
0450: * Retrieves the value of the designated column in the current row
0451: * of this <code>ResultSet</code> object as
0452: * a <code>String</code> in the Java programming language.
0453: *
0454: * @param columnName the SQL name of the column
0455: * @return the column value; if the value is SQL <code>NULL</code>, the
0456: * value returned is <code>null</code>
0457: * @exception SQLException if a database access error occurs
0458: */
0459: public String getString(String columnName) throws SQLException {
0460: int colIndex = -1;
0461: for (int i = 0; i < this .columnNames.length; i++) {
0462: if (columnName.equalsIgnoreCase(this .columnNames[i])) {
0463: colIndex = i;
0464: lastIndexRead = i + 1;
0465: }
0466: }
0467: if (colIndex == -1)
0468: throw new SQLException("Column " + columnName
0469: + " not found.");
0470: return this .columnValues[colIndex];
0471: }
0472:
0473: /**
0474: * Retrieves the value of the designated column in the current row
0475: * of this <code>ResultSet</code> object as
0476: * a <code>boolean</code> in the Java programming language.
0477: *
0478: * @param columnName the SQL name of the column
0479: * @return the column value; if the value is SQL <code>NULL</code>, the
0480: * value returned is <code>false</code>
0481: * @exception SQLException if a database access error occurs
0482: */
0483: public boolean getBoolean(String columnName) throws SQLException {
0484: String str = getString(columnName);
0485: return (str == null) ? false : Boolean.valueOf(str)
0486: .booleanValue();
0487: }
0488:
0489: /**
0490: * Retrieves the value of the designated column in the current row
0491: * of this <code>ResultSet</code> object as
0492: * a <code>byte</code> in the Java programming language.
0493: *
0494: * @param columnName the SQL name of the column
0495: * @return the column value; if the value is SQL <code>NULL</code>, the
0496: * value returned is <code>0</code>
0497: * @exception SQLException if a database access error occurs
0498: */
0499: public byte getByte(String columnName) throws SQLException {
0500: String str = getString(columnName);
0501: return (str == null) ? 0 : Byte.parseByte(str);
0502: }
0503:
0504: /**
0505: * Retrieves the value of the designated column in the current row
0506: * of this <code>ResultSet</code> object as
0507: * a <code>short</code> in the Java programming language.
0508: *
0509: * @param columnName the SQL name of the column
0510: * @return the column value; if the value is SQL <code>NULL</code>, the
0511: * value returned is <code>0</code>
0512: * @exception SQLException if a database access error occurs
0513: */
0514: public short getShort(String columnName) throws SQLException {
0515: String str = getString(columnName);
0516: return (str == null) ? 0 : Short.parseShort(str);
0517: }
0518:
0519: /**
0520: * Gets the value of the designated column in the current row
0521: * of this <code>ResultSet</code> object as
0522: * an <code>int</code> in the Java programming language.
0523: *
0524: * @param columnName the SQL name of the column
0525: * @return the column value; if the value is SQL <code>NULL</code>, the
0526: * value returned is <code>0</code>
0527: * @exception SQLException if a database access error occurs
0528: */
0529: public int getInt(String columnName) throws SQLException {
0530: String str = getString(columnName);
0531: return (str == null) ? 0 : Integer.parseInt(str);
0532: }
0533:
0534: /**
0535: * Retrieves the value of the designated column in the current row
0536: * of this <code>ResultSet</code> object as
0537: * a <code>long</code> in the Java programming language.
0538: *
0539: * @param columnName the SQL name of the column
0540: * @return the column value; if the value is SQL <code>NULL</code>, the
0541: * value returned is <code>0</code>
0542: * @exception SQLException if a database access error occurs
0543: */
0544: public long getLong(String columnName) throws SQLException {
0545: String str = getString(columnName);
0546: return (str == null) ? 0L : Long.parseLong(str);
0547: }
0548:
0549: /**
0550: * Gets the value of the designated column in the current row
0551: * of this <code>ResultSet</code> object as
0552: * a <code>float</code> in the Java programming language.
0553: *
0554: * @param columnName the SQL name of the column
0555: * @return the column value; if the value is SQL <code>NULL</code>, the
0556: * value returned is <code>0</code>
0557: * @exception SQLException if a database access error occurs
0558: */
0559: public float getFloat(String columnName) throws SQLException {
0560: String str = getString(columnName);
0561: return (str == null) ? 0F : Float.parseFloat(str);
0562: }
0563:
0564: /**
0565: * Retrieves the value of the designated column in the current row
0566: * of this <code>ResultSet</code> object as
0567: * a <code>double</code> in the Java programming language.
0568: *
0569: * @param columnName the SQL name of the column
0570: * @return the column value; if the value is SQL <code>NULL</code>, the
0571: * value returned is <code>0</code>
0572: * @exception SQLException if a database access error occurs
0573: */
0574: public double getDouble(String columnName) throws SQLException {
0575: String str = getString(columnName);
0576: return (str == null) ? 0D : Double.parseDouble(str);
0577: }
0578:
0579: /**
0580: * Retrieves the value of the designated column in the current row
0581: * of this <code>ResultSet</code> object as
0582: * a <code>java.math.BigDecimal</code> in the Java programming language.
0583: *
0584: * @param columnName the SQL name of the column
0585: * @param scale the number of digits to the right of the decimal point
0586: * @return the column value; if the value is SQL <code>NULL</code>, the
0587: * value returned is <code>null</code>
0588: * @exception SQLException if a database access error occurs
0589: * @deprecated
0590: */
0591: public BigDecimal getBigDecimal(String columnName, int scale)
0592: throws SQLException {
0593: // let getBigDecimal(String) handle this for now
0594: return getBigDecimal(columnName);
0595: }
0596:
0597: /**
0598: * Retrieves the value of the designated column in the current row
0599: * of this <code>ResultSet</code> object as
0600: * a <code>byte</code> array in the Java programming language.
0601: * The bytes represent the raw values returned by the driver.
0602: *
0603: * @param columnName the SQL name of the column
0604: * @return the column value; if the value is SQL <code>NULL</code>, the
0605: * value returned is <code>null</code>
0606: * @exception SQLException if a database access error occurs
0607: */
0608: public byte[] getBytes(String columnName) throws SQLException {
0609: String str = getString(columnName);
0610: return (str == null) ? null : str.getBytes();
0611: }
0612:
0613: /**
0614: * Retrieves the value of the designated column in the current row
0615: * of this <code>ResultSet</code> object as
0616: * a <code>java.sql.Date</code> object in the Java programming language.
0617: *
0618: * @param columnName the SQL name of the column
0619: * @return the column value; if the value is SQL <code>NULL</code>, the
0620: * value returned is <code>null</code>
0621: * @exception SQLException if a database access error occurs
0622: */
0623: public Date getDate(String columnName) throws SQLException {
0624: String str = getString(columnName);
0625: return (str == null) ? null : Date.valueOf(str);
0626: }
0627:
0628: /**
0629: * Retrieves the value of the designated column in the current row
0630: * of this <code>ResultSet</code> object as
0631: * a <code>java.sql.Time</code> object in the Java programming language.
0632: *
0633: * @param columnName the SQL name of the column
0634: * @return the column value;
0635: * if the value is SQL <code>NULL</code>,
0636: * the value returned is <code>null</code>
0637: * @exception SQLException if a database access error occurs
0638: */
0639: public Time getTime(String columnName) throws SQLException {
0640: String str = getString(columnName);
0641: return (str == null) ? null : Time.valueOf(str);
0642: }
0643:
0644: /**
0645: * Retrieves the value of the designated column in the current row
0646: * of this <code>ResultSet</code> object as
0647: * a <code>java.sql.Timestamp</code> object.
0648: *
0649: * @param columnName the SQL name of the column
0650: * @return the column value; if the value is SQL <code>NULL</code>, the
0651: * value returned is <code>null</code>
0652: * @exception SQLException if a database access error occurs
0653: */
0654: public Timestamp getTimestamp(String columnName)
0655: throws SQLException {
0656: String str = getString(columnName);
0657: return (str == null) ? null : Timestamp.valueOf(str);
0658: }
0659:
0660: /**
0661: * Retrieves the value of the designated column in the current row
0662: * of this <code>ResultSet</code> object as a stream of
0663: * ASCII characters. The value can then be read in chunks from the
0664: * stream. This method is particularly
0665: * suitable for retrieving large <code>LONGVARCHAR</code> values.
0666: * The JDBC driver will
0667: * do any necessary conversion from the database format into ASCII.
0668: *
0669: * <P><B>Note:</B> All the data in the returned stream must be
0670: * read prior to getting the value of any other column. The next
0671: * call to a getter method implicitly closes the stream. Also, a
0672: * stream may return <code>0</code> when the method <code>available</code>
0673: * is called whether there is data available or not.
0674: *
0675: * @param columnName the SQL name of the column
0676: * @return a Java input stream that delivers the database column value
0677: * as a stream of one-byte ASCII characters.
0678: * If the value is SQL <code>NULL</code>,
0679: * the value returned is <code>null</code>.
0680: * @exception SQLException if a database access error occurs
0681: */
0682: public InputStream getAsciiStream(String columnName)
0683: throws SQLException {
0684: String str = getString(columnName);
0685: is = new ByteArrayInputStream(str.getBytes());
0686: return (str == null) ? null : is;
0687: }
0688:
0689: /**
0690: * Retrieves the value of the designated column in the current row
0691: * of this <code>ResultSet</code> object as a stream of two-byte
0692: * Unicode characters. The first byte is the high byte; the second
0693: * byte is the low byte.
0694: *
0695: * The value can then be read in chunks from the
0696: * stream. This method is particularly
0697: * suitable for retrieving large <code>LONGVARCHAR</code> values.
0698: * The JDBC technology-enabled driver will
0699: * do any necessary conversion from the database format into Unicode.
0700: *
0701: * <P><B>Note:</B> All the data in the returned stream must be
0702: * read prior to getting the value of any other column. The next
0703: * call to a getter method implicitly closes the stream.
0704: * Also, a stream may return <code>0</code> when the method
0705: * <code>InputStream.available</code> is called, whether there
0706: * is data available or not.
0707: *
0708: * @param columnName the SQL name of the column
0709: * @return a Java input stream that delivers the database column value
0710: * as a stream of two-byte Unicode characters.
0711: * If the value is SQL <code>NULL</code>, the value returned
0712: * is <code>null</code>.
0713: * @exception SQLException if a database access error occurs
0714: * @deprecated use <code>getCharacterStream</code> instead
0715: */
0716: public InputStream getUnicodeStream(String columnName)
0717: throws SQLException {
0718: // delegate to getAsciiStream(String)
0719: return getAsciiStream(columnName);
0720: }
0721:
0722: /**
0723: * Retrieves the value of the designated column in the current row
0724: * of this <code>ResultSet</code> object as a stream of uninterpreted
0725: * <code>byte</code>s.
0726: * The value can then be read in chunks from the
0727: * stream. This method is particularly
0728: * suitable for retrieving large <code>LONGVARBINARY</code>
0729: * values.
0730: *
0731: * <P><B>Note:</B> All the data in the returned stream must be
0732: * read prior to getting the value of any other column. The next
0733: * call to a getter method implicitly closes the stream. Also, a
0734: * stream may return <code>0</code> when the method <code>available</code>
0735: * is called whether there is data available or not.
0736: *
0737: * @param columnName the SQL name of the column
0738: * @return a Java input stream that delivers the database column value
0739: * as a stream of uninterpreted bytes;
0740: * if the value is SQL <code>NULL</code>, the result is <code>null</code>
0741: * @exception SQLException if a database access error occurs
0742: */
0743: public InputStream getBinaryStream(String columnName)
0744: throws SQLException {
0745: // delegate to getAsciiStream(String)
0746: return getAsciiStream(columnName);
0747: }
0748:
0749: //=====================================================================
0750: // Advanced features:
0751: //=====================================================================
0752:
0753: /**
0754: * Retrieves the first warning reported by calls on this
0755: * <code>ResultSet</code> object.
0756: * Subsequent warnings on this <code>ResultSet</code> object
0757: * will be chained to the <code>SQLWarning</code> object that
0758: * this method returns.
0759: *
0760: * <P>The warning chain is automatically cleared each time a new
0761: * row is read. This method may not be called on a <code>ResultSet</code>
0762: * object that has been closed; doing so will cause an
0763: * <code>SQLException</code> to be thrown.
0764: * <P>
0765: * <B>Note:</B> This warning chain only covers warnings caused
0766: * by <code>ResultSet</code> methods. Any warning caused by
0767: * <code>Statement</code> methods
0768: * (such as reading OUT parameters) will be chained on the
0769: * <code>Statement</code> object.
0770: *
0771: * @return the first <code>SQLWarning</code> object reported or
0772: * <code>null</code> if there are none
0773: * @exception SQLException if a database access error occurs or this method
0774: * is called on a closed result set
0775: */
0776: public SQLWarning getWarnings() throws SQLException {
0777: throw new UnsupportedOperationException(
0778: "ResultSet.getWarnings() unsupported");
0779: }
0780:
0781: /**
0782: * Clears all warnings reported on this <code>ResultSet</code> object.
0783: * After this method is called, the method <code>getWarnings</code>
0784: * returns <code>null</code> until a new warning is
0785: * reported for this <code>ResultSet</code> object.
0786: *
0787: * @exception SQLException if a database access error occurs
0788: */
0789: public void clearWarnings() throws SQLException {
0790: throw new UnsupportedOperationException(
0791: "ResultSet.clearWarnings() unsupported");
0792: }
0793:
0794: /**
0795: * Retrieves the name of the SQL cursor used by this <code>ResultSet</code>
0796: * object.
0797: *
0798: * <P>In SQL, a result table is retrieved through a cursor that is
0799: * named. The current row of a result set can be updated or deleted
0800: * using a positioned update/delete statement that references the
0801: * cursor name. To insure that the cursor has the proper isolation
0802: * level to support update, the cursor's <code>SELECT</code> statement
0803: * should be of the form <code>SELECT FOR UPDATE</code>. If
0804: * <code>FOR UPDATE</code> is omitted, the positioned updates may fail.
0805: *
0806: * <P>The JDBC API supports this SQL feature by providing the name of the
0807: * SQL cursor used by a <code>ResultSet</code> object.
0808: * The current row of a <code>ResultSet</code> object
0809: * is also the current row of this SQL cursor.
0810: *
0811: * <P><B>Note:</B> If positioned update is not supported, a
0812: * <code>SQLException</code> is thrown.
0813: *
0814: * @return the SQL name for this <code>ResultSet</code> object's cursor
0815: * @exception SQLException if a database access error occurs
0816: */
0817: public String getCursorName() throws SQLException {
0818: throw new UnsupportedOperationException(
0819: "ResultSet.getCursorName() unsupported");
0820: }
0821:
0822: /**
0823: * Retrieves the number, types and properties of
0824: * this <code>ResultSet</code> object's columns.
0825: *
0826: * @return the description of this <code>ResultSet</code> object's columns
0827: * @exception SQLException if a database access error occurs
0828: */
0829: public ResultSetMetaData getMetaData() throws SQLException {
0830: if (resultSetMetaData == null) {
0831: resultSetMetaData = new XmlResultSetMetaData(tableName,
0832: columnNames);
0833: }
0834: return resultSetMetaData;
0835:
0836: }
0837:
0838: /**
0839: * <p>Gets the value of the designated column in the current row
0840: * of this <code>ResultSet</code> object as
0841: * an <code>Object</code> in the Java programming language.
0842: *
0843: * <p>This method will return the value of the given column as a
0844: * Java object. The type of the Java object will be the default
0845: * Java object type corresponding to the column's SQL type,
0846: * following the mapping for built-in types specified in the JDBC
0847: * specification. If the value is an SQL <code>NULL</code>,
0848: * the driver returns a Java <code>null</code>.
0849: *
0850: * <p>This method may also be used to read datatabase-specific
0851: * abstract data types.
0852: *
0853: * In the JDBC 2.0 API, the behavior of method
0854: * <code>getObject</code> is extended to materialize
0855: * data of SQL user-defined types. When a column contains
0856: * a structured or distinct value, the behavior of this method is as
0857: * if it were a call to: <code>getObject(columnIndex,
0858: * this.getStatement().getConnection().getTypeMap())</code>.
0859: *
0860: * @param columnIndex the first column is 1, the second is 2, ...
0861: * @return a <code>java.lang.Object</code> holding the column value
0862: * @exception SQLException if a database access error occurs
0863: */
0864: public Object getObject(int columnIndex) throws SQLException {
0865: // throw new UnsupportedOperationException(
0866: // "ResultSet.getObject(int) unsupported");
0867: return getString(columnIndex);
0868: }
0869:
0870: /**
0871: * <p>Gets the value of the designated column in the current row
0872: * of this <code>ResultSet</code> object as
0873: * an <code>Object</code> in the Java programming language.
0874: *
0875: * <p>This method will return the value of the given column as a
0876: * Java object. The type of the Java object will be the default
0877: * Java object type corresponding to the column's SQL type,
0878: * following the mapping for built-in types specified in the JDBC
0879: * specification. If the value is an SQL <code>NULL</code>,
0880: * the driver returns a Java <code>null</code>.
0881: * <P>
0882: * This method may also be used to read datatabase-specific
0883: * abstract data types.
0884: * <P>
0885: * In the JDBC 2.0 API, the behavior of the method
0886: * <code>getObject</code> is extended to materialize
0887: * data of SQL user-defined types. When a column contains
0888: * a structured or distinct value, the behavior of this method is as
0889: * if it were a call to: <code>getObject(columnIndex,
0890: * this.getStatement().getConnection().getTypeMap())</code>.
0891: *
0892: * @param columnName the SQL name of the column
0893: * @return a <code>java.lang.Object</code> holding the column value
0894: * @exception SQLException if a database access error occurs
0895: */
0896: public Object getObject(String columnName) throws SQLException {
0897: // throw new UnsupportedOperationException(
0898: // "ResultSet.getObject(String) unsupported");
0899: return getString(columnName);
0900: }
0901:
0902: /**
0903: * Maps the given <code>ResultSet</code> column name to its
0904: * <code>ResultSet</code> column index.
0905: *
0906: * @param columnName the name of the column
0907: * @return the column index of the given column name
0908: * @exception SQLException if the <code>ResultSet</code> object does
0909: * not contain <code>columnName</code> or a database access error occurs
0910: */
0911: public int findColumn(String columnName) throws SQLException {
0912: throw new UnsupportedOperationException(
0913: "ResultSet.findColumn(String) unsupported");
0914: }
0915:
0916: //--------------------------JDBC 2.0-----------------------------------
0917:
0918: //---------------------------------------------------------------------
0919: // Getters and Setters
0920: //---------------------------------------------------------------------
0921:
0922: /**
0923: * Retrieves the value of the designated column in the current row
0924: * of this <code>ResultSet</code> object as a
0925: * <code>java.io.Reader</code> object.
0926: *
0927: * @param columnIndex the first column is 1, the second is 2, ...
0928: * @return a <code>java.io.Reader</code> object that contains the column
0929: * value; if the value is SQL <code>NULL</code>, the value returned is
0930: * <code>null</code> in the Java programming language.
0931: * @exception SQLException if a database access error occurs
0932: */
0933: public Reader getCharacterStream(int columnIndex)
0934: throws SQLException {
0935: String str = getString(columnIndex);
0936: return (str == null) ? null : new StringReader(str);
0937: }
0938:
0939: /**
0940: * Retrieves the value of the designated column in the current row
0941: * of this <code>ResultSet</code> object as a
0942: * <code>java.io.Reader</code> object.
0943: *
0944: * @param columnName the name of the column
0945: * @return a <code>java.io.Reader</code> object that contains the column
0946: * value; if the value is SQL <code>NULL</code>, the value returned is
0947: * <code>null</code> in the Java programming language
0948: * @exception SQLException if a database access error occurs
0949: */
0950: public Reader getCharacterStream(String columnName)
0951: throws SQLException {
0952: String str = getString(columnName);
0953: return (str == null) ? null : new StringReader(str);
0954: }
0955:
0956: /**
0957: * Retrieves the value of the designated column in the current row
0958: * of this <code>ResultSet</code> object as a
0959: * <code>java.math.BigDecimal</code> with full precision.
0960: *
0961: * @param columnIndex the first column is 1, the second is 2, ...
0962: * @return the column value (full precision);
0963: * if the value is SQL <code>NULL</code>, the value returned is
0964: * <code>null</code> in the Java programming language.
0965: * @exception SQLException if a database access error occurs
0966: */
0967: public BigDecimal getBigDecimal(int columnIndex)
0968: throws SQLException {
0969: BigDecimal retval = null;
0970: String str = getString(columnIndex);
0971: if (str != null) {
0972: try {
0973: retval = new BigDecimal(str);
0974: } catch (NumberFormatException e) {
0975: throw new SQLException("Could not convert '" + str
0976: + "' to " + "a java.math.BigDecimal object");
0977: }
0978: }
0979: return retval;
0980: }
0981:
0982: /**
0983: * Retrieves the value of the designated column in the current row
0984: * of this <code>ResultSet</code> object as a
0985: * <code>java.math.BigDecimal</code> with full precision.
0986: *
0987: * @param columnName the column name
0988: * @return the column value (full precision);
0989: * if the value is SQL <code>NULL</code>, the value returned is
0990: * <code>null</code> in the Java programming language.
0991: * @exception SQLException if a database access error occurs
0992: */
0993: public BigDecimal getBigDecimal(String columnName)
0994: throws SQLException {
0995: BigDecimal retval = null;
0996: String str = getString(columnName);
0997: if (str != null) {
0998: try {
0999: retval = new BigDecimal(str);
1000: } catch (NumberFormatException e) {
1001: throw new SQLException("Could not convert '" + str
1002: + "' to " + "a java.math.BigDecimal object");
1003: }
1004: }
1005: return retval;
1006: }
1007:
1008: //---------------------------------------------------------------------
1009: // Traversal/Positioning
1010: //---------------------------------------------------------------------
1011:
1012: /**
1013: * Retrieves whether the cursor is before the first row in
1014: * this <code>ResultSet</code> object.
1015: *
1016: * @return <code>true</code> if the cursor is before the first row;
1017: * <code>false</code> if the cursor is at any other position or the
1018: * result set contains no rows
1019: * @exception SQLException if a database access error occurs
1020: */
1021: public boolean isBeforeFirst() throws SQLException {
1022: throw new UnsupportedOperationException(
1023: "ResultSet.isBeforeFirst() unsupported");
1024: }
1025:
1026: /**
1027: * Retrieves whether the cursor is after the last row in
1028: * this <code>ResultSet</code> object.
1029: *
1030: * @return <code>true</code> if the cursor is after the last row;
1031: * <code>false</code> if the cursor is at any other position or the
1032: * result set contains no rows
1033: * @exception SQLException if a database access error occurs
1034: */
1035: public boolean isAfterLast() throws SQLException {
1036: throw new UnsupportedOperationException(
1037: "ResultSet.isAfterLast() unsupported");
1038: }
1039:
1040: /**
1041: * Retrieves whether the cursor is on the first row of
1042: * this <code>ResultSet</code> object.
1043: *
1044: * @return <code>true</code> if the cursor is on the first row;
1045: * <code>false</code> otherwise
1046: * @exception SQLException if a database access error occurs
1047: */
1048: public boolean isFirst() throws SQLException {
1049: throw new UnsupportedOperationException(
1050: "ResultSet.isFirst() unsupported");
1051: }
1052:
1053: /**
1054: * Retrieves whether the cursor is on the last row of
1055: * this <code>ResultSet</code> object.
1056: * Note: Calling the method <code>isLast</code> may be expensive
1057: * because the JDBC driver
1058: * might need to fetch ahead one row in order to determine
1059: * whether the current row is the last row in the result set.
1060: *
1061: * @return <code>true</code> if the cursor is on the last row;
1062: * <code>false</code> otherwise
1063: * @exception SQLException if a database access error occurs
1064: */
1065: public boolean isLast() throws SQLException {
1066: throw new UnsupportedOperationException(
1067: "ResultSet.isLast() unsupported");
1068: }
1069:
1070: /**
1071: * Moves the cursor to the front of
1072: * this <code>ResultSet</code> object, just before the
1073: * first row. This method has no effect if the result set contains no rows.
1074: *
1075: * @exception SQLException if a database access error
1076: * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1077: */
1078: public void beforeFirst() throws SQLException {
1079: throw new UnsupportedOperationException(
1080: "ResultSet.beforeFirst() unsupported");
1081: }
1082:
1083: /**
1084: * Moves the cursor to the end of
1085: * this <code>ResultSet</code> object, just after the
1086: * last row. This method has no effect if the result set contains no rows.
1087: * @exception SQLException if a database access error
1088: * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1089: */
1090: public void afterLast() throws SQLException {
1091: throw new UnsupportedOperationException(
1092: "ResultSet.afterLast() unsupported");
1093: }
1094:
1095: /**
1096: * Moves the cursor to the first row in
1097: * this <code>ResultSet</code> object.
1098: *
1099: * @return <code>true</code> if the cursor is on a valid row;
1100: * <code>false</code> if there are no rows in the result set
1101: * @exception SQLException if a database access error
1102: * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1103: */
1104: public boolean first() throws SQLException {
1105: throw new UnsupportedOperationException(
1106: "ResultSet.first() unsupported");
1107: }
1108:
1109: /**
1110: * Moves the cursor to the last row in
1111: * this <code>ResultSet</code> object.
1112: *
1113: * @return <code>true</code> if the cursor is on a valid row;
1114: * <code>false</code> if there are no rows in the result set
1115: * @exception SQLException if a database access error
1116: * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1117: */
1118: public boolean last() throws SQLException {
1119: throw new UnsupportedOperationException(
1120: "ResultSet.last() unsupported");
1121: }
1122:
1123: /**
1124: * Retrieves the current row number. The first row is number 1, the
1125: * second number 2, and so on.
1126: *
1127: * @return the current row number; <code>0</code> if there is no current row
1128: * @exception SQLException if a database access error occurs
1129: */
1130: public int getRow() throws SQLException {
1131: throw new UnsupportedOperationException(
1132: "ResultSet.getRow() unsupported");
1133: }
1134:
1135: /**
1136: * Moves the cursor to the given row number in
1137: * this <code>ResultSet</code> object.
1138: *
1139: * <p>If the row number is positive, the cursor moves to
1140: * the given row number with respect to the
1141: * beginning of the result set. The first row is row 1, the second
1142: * is row 2, and so on.
1143: *
1144: * <p>If the given row number is negative, the cursor moves to
1145: * an absolute row position with respect to
1146: * the end of the result set. For example, calling the method
1147: * <code>absolute(-1)</code> positions the
1148: * cursor on the last row; calling the method <code>absolute(-2)</code>
1149: * moves the cursor to the next-to-last row, and so on.
1150: *
1151: * <p>An attempt to position the cursor beyond the first/last row in
1152: * the result set leaves the cursor before the first row or after
1153: * the last row.
1154: *
1155: * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
1156: * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
1157: * is the same as calling <code>last()</code>.
1158: *
1159: * @param row the number of the row to which the cursor should move.
1160: * A positive number indicates the row number counting from the
1161: * beginning of the result set; a negative number indicates the
1162: * row number counting from the end of the result set
1163: * @return <code>true</code> if the cursor is on the result set;
1164: * <code>false</code> otherwise
1165: * @exception SQLException if a database access error
1166: * occurs, or the result set type is <code>TYPE_FORWARD_ONLY</code>
1167: */
1168: public boolean absolute(int row) throws SQLException {
1169: throw new UnsupportedOperationException(
1170: "ResultSet.absolute() unsupported");
1171: }
1172:
1173: /**
1174: * Moves the cursor a relative number of rows, either positive or negative.
1175: * Attempting to move beyond the first/last row in the
1176: * result set positions the cursor before/after the
1177: * the first/last row. Calling <code>relative(0)</code> is valid, but does
1178: * not change the cursor position.
1179: *
1180: * <p>Note: Calling the method <code>relative(1)</code>
1181: * is identical to calling the method <code>next()</code> and
1182: * calling the method <code>relative(-1)</code> is identical
1183: * to calling the method <code>previous()</code>.
1184: *
1185: * @param rows an <code>int</code> specifying the number of rows to
1186: * move from the current row; a positive number moves the cursor
1187: * forward; a negative number moves the cursor backward
1188: * @return <code>true</code> if the cursor is on a row;
1189: * <code>false</code> otherwise
1190: * @exception SQLException if a database access error occurs,
1191: * there is no current row, or the result set type is
1192: * <code>TYPE_FORWARD_ONLY</code>
1193: */
1194: public boolean relative(int rows) throws SQLException {
1195: throw new UnsupportedOperationException(
1196: "ResultSet.relative() unsupported");
1197: }
1198:
1199: /**
1200: * Moves the cursor to the previous row in this
1201: * <code>ResultSet</code> object.
1202: *
1203: * @return <code>true</code> if the cursor is on a valid row;
1204: * <code>false</code> if it is off the result set
1205: * @exception SQLException if a database access error
1206: * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1207: */
1208: public boolean previous() throws SQLException {
1209: throw new UnsupportedOperationException(
1210: "ResultSet.previous() unsupported");
1211: }
1212:
1213: //---------------------------------------------------------------------
1214: // Properties
1215: //---------------------------------------------------------------------
1216:
1217: /**
1218: * Gives a hint as to the direction in which the rows in this
1219: * <code>ResultSet</code> object will be processed. The initial value is
1220: * determined by the <code>Statement</code> object that produced this
1221: * <code>ResultSet</code> object. The fetch direction may be changed at
1222: * any time.
1223: *
1224: * @param direction an <code>int</code> specifying the suggested
1225: * fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>,
1226: * <code>ResultSet.FETCH_REVERSE</code>, or
1227: * <code>ResultSet.FETCH_UNKNOWN</code>
1228: * @exception SQLException if a database access error occurs or
1229: * the result set type is <code>TYPE_FORWARD_ONLY</code>
1230: * and the fetch direction is not <code>FETCH_FORWARD</code>
1231: */
1232: public void setFetchDirection(int direction) throws SQLException {
1233: throw new UnsupportedOperationException(
1234: "ResultSet.setFetchDirection(int) unsupported");
1235: }
1236:
1237: /**
1238: * Retrieves the fetch direction for this
1239: * <code>ResultSet</code> object.
1240: *
1241: * @return the current fetch direction for this <code>ResultSet</code>
1242: * object
1243: * @exception SQLException if a database access error occurs
1244: * @see #setFetchDirection
1245: */
1246: public int getFetchDirection() throws SQLException {
1247: throw new UnsupportedOperationException(
1248: "ResultSet.getFetchDirection() unsupported");
1249: }
1250:
1251: /**
1252: * Gives the JDBC driver a hint as to the number of rows that should
1253: * be fetched from the database when more rows are needed for this
1254: * <code>ResultSet</code> object. If the fetch size specified is zero,
1255: * the JDBC driver ignores the value and is free to make its own best
1256: * guess as to what the fetch size should be. The default value is set
1257: * by the <code>Statement</code> object that created the result set.
1258: * The fetch size may be changed at any time.
1259: *
1260: * @param rows the number of rows to fetch
1261: * @exception SQLException if a database access error occurs or the
1262: * condition <code>0 <= rows <= this.getMaxRows()</code> is not satisfied
1263: */
1264: public void setFetchSize(int rows) throws SQLException {
1265: throw new UnsupportedOperationException(
1266: "ResultSet.setFetchSize(int) unsupported");
1267: }
1268:
1269: /**
1270: * Retrieves the fetch size for this
1271: * <code>ResultSet</code> object.
1272: *
1273: * @return the current fetch size for this <code>ResultSet</code> object
1274: * @exception SQLException if a database access error occurs
1275: * @see #setFetchSize
1276: */
1277: public int getFetchSize() throws SQLException {
1278: throw new UnsupportedOperationException(
1279: "ResultSet.getFetchSize() unsupported");
1280: }
1281:
1282: /**
1283: * Retrieves the type of this <code>ResultSet</code> object.
1284: * The type is determined by the <code>Statement</code> object
1285: * that created the result set.
1286: *
1287: * @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
1288: * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
1289: * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
1290: * @exception SQLException if a database access error occurs
1291: */
1292: public int getType() throws SQLException {
1293: throw new UnsupportedOperationException(
1294: "ResultSet.getType() unsupported");
1295: }
1296:
1297: /**
1298: * Retrieves the concurrency mode of this <code>ResultSet</code> object.
1299: * The concurrency used is determined by the
1300: * <code>Statement</code> object that created the result set.
1301: *
1302: * @return the concurrency type, either
1303: * <code>ResultSet.CONCUR_READ_ONLY</code>
1304: * or <code>ResultSet.CONCUR_UPDATABLE</code>
1305: * @exception SQLException if a database access error occurs
1306: */
1307: public int getConcurrency() throws SQLException {
1308: return CONCUR_READ_ONLY;
1309: }
1310:
1311: //---------------------------------------------------------------------
1312: // Updates
1313: //---------------------------------------------------------------------
1314:
1315: /**
1316: * Retrieves whether the current row has been updated. The value returned
1317: * depends on whether or not the result set can detect updates.
1318: *
1319: * @return <code>true</code> if both (1) the row has been visibly updated
1320: * by the owner or another and (2) updates are detected
1321: * @exception SQLException if a database access error occurs
1322: * @see DatabaseMetaData#updatesAreDetected
1323: */
1324: public boolean rowUpdated() throws SQLException {
1325: throw new UnsupportedOperationException(
1326: "ResultSet.rowUpdated() unsupported");
1327: }
1328:
1329: /**
1330: * Retrieves whether the current row has had an insertion.
1331: * The value returned depends on whether or not this
1332: * <code>ResultSet</code> object can detect visible inserts.
1333: *
1334: * @return <code>true</code> if a row has had an insertion
1335: * and insertions are detected; <code>false</code> otherwise
1336: * @exception SQLException if a database access error occurs
1337: *
1338: * @see DatabaseMetaData#insertsAreDetected
1339: */
1340: public boolean rowInserted() throws SQLException {
1341: throw new UnsupportedOperationException(
1342: "ResultSet.rowInserted() unsupported");
1343: }
1344:
1345: /**
1346: * Retrieves whether a row has been deleted. A deleted row may leave
1347: * a visible "hole" in a result set. This method can be used to
1348: * detect holes in a result set. The value returned depends on whether
1349: * or not this <code>ResultSet</code> object can detect deletions.
1350: *
1351: * @return <code>true</code> if a row was deleted and deletions are
1352: * detected; <code>false</code> otherwise
1353: * @exception SQLException if a database access error occurs
1354: *
1355: * @see DatabaseMetaData#deletesAreDetected
1356: */
1357: public boolean rowDeleted() throws SQLException {
1358: throw new UnsupportedOperationException(
1359: "ResultSet.rowDeleted() unsupported");
1360: }
1361:
1362: /**
1363: * Gives a nullable column a null value.
1364: *
1365: * The updater methods are used to update column values in the
1366: * current row or the insert row. The updater methods do not
1367: * update the underlying database; instead the <code>updateRow</code>
1368: * or <code>insertRow</code> methods are called to update the database.
1369: *
1370: * @param columnIndex the first column is 1, the second is 2, ...
1371: * @exception SQLException if a database access error occurs
1372: */
1373: public void updateNull(int columnIndex) throws SQLException {
1374: throw new UnsupportedOperationException(
1375: "ResultSet.updateNull() unsupported");
1376: }
1377:
1378: /**
1379: * Updates the designated column with a <code>boolean</code> value.
1380: * The updater methods are used to update column values in the
1381: * current row or the insert row. The updater methods do not
1382: * update the underlying database; instead the <code>updateRow</code> or
1383: * <code>insertRow</code> methods are called to update the database.
1384: *
1385: * @param columnIndex the first column is 1, the second is 2, ...
1386: * @param x the new column value
1387: * @exception SQLException if a database access error occurs
1388: */
1389: public void updateBoolean(int columnIndex, boolean x)
1390: throws SQLException {
1391: throw new UnsupportedOperationException(
1392: "ResultSet.updateBoolean() unsupported");
1393: }
1394:
1395: /**
1396: * Updates the designated column with a <code>byte</code> value.
1397: * The updater methods are used to update column values in the
1398: * current row or the insert row. The updater methods do not
1399: * update the underlying database; instead the <code>updateRow</code> or
1400: * <code>insertRow</code> methods are called to update the database.
1401: *
1402: *
1403: * @param columnIndex the first column is 1, the second is 2, ...
1404: * @param x the new column value
1405: * @exception SQLException if a database access error occurs
1406: */
1407: public void updateByte(int columnIndex, byte x) throws SQLException {
1408: throw new UnsupportedOperationException(
1409: "ResultSet.updateByte() unsupported");
1410: }
1411:
1412: /**
1413: * Updates the designated column with a <code>short</code> value.
1414: * The updater methods are used to update column values in the
1415: * current row or the insert row. The updater methods do not
1416: * update the underlying database; instead the <code>updateRow</code> or
1417: * <code>insertRow</code> methods are called to update the database.
1418: *
1419: * @param columnIndex the first column is 1, the second is 2, ...
1420: * @param x the new column value
1421: * @exception SQLException if a database access error occurs
1422: */
1423: public void updateShort(int columnIndex, short x)
1424: throws SQLException {
1425: throw new UnsupportedOperationException(
1426: "ResultSet.updateShort() unsupported");
1427: }
1428:
1429: /**
1430: * Updates the designated column with an <code>int</code> value.
1431: * The updater methods are used to update column values in the
1432: * current row or the insert row. The updater methods do not
1433: * update the underlying database; instead the <code>updateRow</code> or
1434: * <code>insertRow</code> methods are called to update the database.
1435: *
1436: * @param columnIndex the first column is 1, the second is 2, ...
1437: * @param x the new column value
1438: * @exception SQLException if a database access error occurs
1439: */
1440: public void updateInt(int columnIndex, int x) throws SQLException {
1441: throw new UnsupportedOperationException(
1442: "ResultSet.updateInt() unsupported");
1443: }
1444:
1445: /**
1446: * Updates the designated column with a <code>long</code> value.
1447: * The updater methods are used to update column values in the
1448: * current row or the insert row. The updater methods do not
1449: * update the underlying database; instead the <code>updateRow</code> or
1450: * <code>insertRow</code> methods are called to update the database.
1451: *
1452: * @param columnIndex the first column is 1, the second is 2, ...
1453: * @param x the new column value
1454: * @exception SQLException if a database access error occurs
1455: */
1456: public void updateLong(int columnIndex, long x) throws SQLException {
1457: throw new UnsupportedOperationException(
1458: "ResultSet.updateLong(int, long) unsupported");
1459: }
1460:
1461: /**
1462: * Updates the designated column with a <code>float</code> value.
1463: * The updater methods are used to update column values in the
1464: * current row or the insert row. The updater methods do not
1465: * update the underlying database; instead the <code>updateRow</code> or
1466: * <code>insertRow</code> methods are called to update the database.
1467: *
1468: * @param columnIndex the first column is 1, the second is 2, ...
1469: * @param x the new column value
1470: * @exception SQLException if a database access error occurs
1471: */
1472: public void updateFloat(int columnIndex, float x)
1473: throws SQLException {
1474: throw new UnsupportedOperationException(
1475: "ResultSet.updateFloat(int, float) unsupported");
1476: }
1477:
1478: /**
1479: * Updates the designated column with a <code>double</code> value.
1480: * The updater methods are used to update column values in the
1481: * current row or the insert row. The updater methods do not
1482: * update the underlying database; instead the <code>updateRow</code> or
1483: * <code>insertRow</code> methods are called to update the database.
1484: *
1485: * @param columnIndex the first column is 1, the second is 2, ...
1486: * @param x the new column value
1487: * @exception SQLException if a database access error occurs
1488: */
1489: public void updateDouble(int columnIndex, double x)
1490: throws SQLException {
1491: throw new UnsupportedOperationException(
1492: "ResultSet.updateDouble(int, double) unsupported");
1493: }
1494:
1495: /**
1496: * Updates the designated column with a <code>java.math.BigDecimal</code>
1497: * value.
1498: * The updater methods are used to update column values in the
1499: * current row or the insert row. The updater methods do not
1500: * update the underlying database; instead the <code>updateRow</code> or
1501: * <code>insertRow</code> methods are called to update the database.
1502: *
1503: * @param columnIndex the first column is 1, the second is 2, ...
1504: * @param x the new column value
1505: * @exception SQLException if a database access error occurs
1506: */
1507: public void updateBigDecimal(int columnIndex, BigDecimal x)
1508: throws SQLException {
1509: throw new UnsupportedOperationException(
1510: "ResultSet.updateBigDecimal(int, BigDecimal) unsupported");
1511: }
1512:
1513: /**
1514: * Updates the designated column with a <code>String</code> value.
1515: * The updater methods are used to update column values in the
1516: * current row or the insert row. The updater methods do not
1517: * update the underlying database; instead the <code>updateRow</code> or
1518: * <code>insertRow</code> methods are called to update the database.
1519: *
1520: * @param columnIndex the first column is 1, the second is 2, ...
1521: * @param x the new column value
1522: * @exception SQLException if a database access error occurs
1523: */
1524: public void updateString(int columnIndex, String x)
1525: throws SQLException {
1526: throw new UnsupportedOperationException(
1527: "ResultSet.updateString(int, String) unsupported");
1528: }
1529:
1530: /**
1531: * Updates the designated column with a <code>byte</code> array value.
1532: * The updater methods are used to update column values in the
1533: * current row or the insert row. The updater methods do not
1534: * update the underlying database; instead the <code>updateRow</code> or
1535: * <code>insertRow</code> methods are called to update the database.
1536: *
1537: * @param columnIndex the first column is 1, the second is 2, ...
1538: * @param x the new column value
1539: * @exception SQLException if a database access error occurs
1540: */
1541: public void updateBytes(int columnIndex, byte[] x)
1542: throws SQLException {
1543: throw new UnsupportedOperationException(
1544: "ResultSet.updateBytes(int, byte[]) unsupported");
1545: }
1546:
1547: /**
1548: * Updates the designated column with a <code>java.sql.Date</code> value.
1549: * The updater methods are used to update column values in the
1550: * current row or the insert row. The updater methods do not
1551: * update the underlying database; instead the <code>updateRow</code> or
1552: * <code>insertRow</code> methods are called to update the database.
1553: *
1554: * @param columnIndex the first column is 1, the second is 2, ...
1555: * @param x the new column value
1556: * @exception SQLException if a database access error occurs
1557: */
1558: public void updateDate(int columnIndex, Date x) throws SQLException {
1559: throw new UnsupportedOperationException(
1560: "ResultSet.updateDate(int, Date) unsupported");
1561: }
1562:
1563: /**
1564: * Updates the designated column with a <code>java.sql.Time</code> value.
1565: * The updater methods are used to update column values in the
1566: * current row or the insert row. The updater methods do not
1567: * update the underlying database; instead the <code>updateRow</code> or
1568: * <code>insertRow</code> methods are called to update the database.
1569: *
1570: * @param columnIndex the first column is 1, the second is 2, ...
1571: * @param x the new column value
1572: * @exception SQLException if a database access error occurs
1573: */
1574: public void updateTime(int columnIndex, Time x) throws SQLException {
1575: throw new UnsupportedOperationException(
1576: "ResultSet.updateTime(int, Time) unsupported");
1577: }
1578:
1579: /**
1580: * Updates the designated column with a <code>java.sql.Timestamp</code>
1581: * value.
1582: * The updater methods are used to update column values in the
1583: * current row or the insert row. The updater methods do not
1584: * update the underlying database; instead the <code>updateRow</code> or
1585: * <code>insertRow</code> methods are called to update the database.
1586: *
1587: * @param columnIndex the first column is 1, the second is 2, ...
1588: * @param x the new column value
1589: * @exception SQLException if a database access error occurs
1590: */
1591: public void updateTimestamp(int columnIndex, Timestamp x)
1592: throws SQLException {
1593: throw new UnsupportedOperationException(
1594: "ResultSet.updateTimestamp(int, Timestamp) unsupported");
1595: }
1596:
1597: /**
1598: * Updates the designated column with an ascii stream value.
1599: * The updater methods are used to update column values in the
1600: * current row or the insert row. The updater methods do not
1601: * update the underlying database; instead the <code>updateRow</code> or
1602: * <code>insertRow</code> methods are called to update the database.
1603: *
1604: * @param columnIndex the first column is 1, the second is 2, ...
1605: * @param x the new column value
1606: * @param length the length of the stream
1607: * @exception SQLException if a database access error occurs
1608: */
1609: public void updateAsciiStream(int columnIndex, InputStream x,
1610: int length) throws SQLException {
1611: throw new UnsupportedOperationException(
1612: "ResultSet.updateAsciiStream "
1613: + "(int, InputStream, int) unsupported");
1614: }
1615:
1616: /**
1617: * Updates the designated column with a binary stream value.
1618: * The updater methods are used to update column values in the
1619: * current row or the insert row. The updater methods do not
1620: * update the underlying database; instead the <code>updateRow</code> or
1621: * <code>insertRow</code> methods are called to update the database.
1622: *
1623: * @param columnIndex the first column is 1, the second is 2, ...
1624: * @param x the new column value
1625: * @param length the length of the stream
1626: * @exception SQLException if a database access error occurs
1627: */
1628: public void updateBinaryStream(int columnIndex, InputStream x,
1629: int length) throws SQLException {
1630: throw new UnsupportedOperationException(
1631: "ResultSet.updateBinaryStream"
1632: + "(int, InputStream, int) unsupported");
1633: }
1634:
1635: /**
1636: * Updates the designated column with a character stream value.
1637: * The updater methods are used to update column values in the
1638: * current row or the insert row. The updater methods do not
1639: * update the underlying database; instead the <code>updateRow</code> or
1640: * <code>insertRow</code> methods are called to update the database.
1641: *
1642: * @param columnIndex the first column is 1, the second is 2, ...
1643: * @param x the new column value
1644: * @param length the length of the stream
1645: * @exception SQLException if a database access error occurs
1646: */
1647: public void updateCharacterStream(int columnIndex, Reader x,
1648: int length) throws SQLException {
1649: throw new UnsupportedOperationException(
1650: "ResultSet.updateCharacterStr"
1651: + "eam(int, Reader, int) unsupported");
1652: }
1653:
1654: /**
1655: * Updates the designated column with an <code>Object</code> value.
1656: * The updater methods are used to update column values in the
1657: * current row or the insert row. The updater methods do not
1658: * update the underlying database; instead the <code>updateRow</code> or
1659: * <code>insertRow</code> methods are called to update the database.
1660: *
1661: * @param columnIndex the first column is 1, the second is 2, ...
1662: * @param x the new column value
1663: * @param scale for <code>java.sql.Types.DECIMA</code>
1664: * or <code>java.sql.Types.NUMERIC</code> types,
1665: * this is the number of digits after the decimal point. For all other
1666: * types this value will be ignored.
1667: * @exception SQLException if a database access error occurs
1668: */
1669: public void updateObject(int columnIndex, Object x, int scale)
1670: throws SQLException {
1671: throw new UnsupportedOperationException(
1672: "ResultSet.udpateObject(int, Object) unsupported");
1673: }
1674:
1675: /**
1676: * Updates the designated column with an <code>Object</code> value.
1677: * The updater methods are used to update column values in the
1678: * current row or the insert row. The updater methods do not
1679: * update the underlying database; instead the <code>updateRow</code> or
1680: * <code>insertRow</code> methods are called to update the database.
1681: *
1682: * @param columnIndex the first column is 1, the second is 2, ...
1683: * @param x the new column value
1684: * @exception SQLException if a database access error occurs
1685: */
1686: public void updateObject(int columnIndex, Object x)
1687: throws SQLException {
1688: throw new UnsupportedOperationException(
1689: "ResultSet.updateObject(int, Object, int) unsupported");
1690: }
1691:
1692: /**
1693: * Updates the designated column with a <code>null</code> value.
1694: * The updater methods are used to update column values in the
1695: * current row or the insert row. The updater methods do not
1696: * update the underlying database; instead the <code>updateRow</code> or
1697: * <code>insertRow</code> methods are called to update the database.
1698: *
1699: * @param columnName the name of the column
1700: * @exception SQLException if a database access error occurs
1701: */
1702: public void updateNull(String columnName) throws SQLException {
1703: throw new UnsupportedOperationException(
1704: "ResultSet.updateNull(String) unsupported");
1705: }
1706:
1707: /**
1708: * Updates the designated column with a <code>boolean</code> value.
1709: * The updater methods are used to update column values in the
1710: * current row or the insert row. The updater methods do not
1711: * update the underlying database; instead the <code>updateRow</code> or
1712: * <code>insertRow</code> methods are called to update the database.
1713: *
1714: * @param columnName the name of the column
1715: * @param x the new column value
1716: * @exception SQLException if a database access error occurs
1717: */
1718: public void updateBoolean(String columnName, boolean x)
1719: throws SQLException {
1720: throw new UnsupportedOperationException(
1721: "ResultSet.updateBoolean(String, boolean) unsupported");
1722: }
1723:
1724: /**
1725: * Updates the designated column with a <code>byte</code> value.
1726: * The updater methods are used to update column values in the
1727: * current row or the insert row. The updater methods do not
1728: * update the underlying database; instead the <code>updateRow</code> or
1729: * <code>insertRow</code> methods are called to update the database.
1730: *
1731: * @param columnName the name of the column
1732: * @param x the new column value
1733: * @exception SQLException if a database access error occurs
1734: */
1735: public void updateByte(String columnName, byte x)
1736: throws SQLException {
1737: throw new UnsupportedOperationException(
1738: "ResultSet.updateByte(String, byte) unsupported");
1739: }
1740:
1741: /**
1742: * Updates the designated column with a <code>short</code> value.
1743: * The updater methods are used to update column values in the
1744: * current row or the insert row. The updater methods do not
1745: * update the underlying database; instead the <code>updateRow</code> or
1746: * <code>insertRow</code> methods are called to update the database.
1747: *
1748: * @param columnName the name of the column
1749: * @param x the new column value
1750: * @exception SQLException if a database access error occurs
1751: */
1752: public void updateShort(String columnName, short x)
1753: throws SQLException {
1754: throw new UnsupportedOperationException(
1755: "ResultSet.updateShort(String, short) unsupported");
1756: }
1757:
1758: /**
1759: * Updates the designated column with an <code>int</code> value.
1760: * The updater methods are used to update column values in the
1761: * current row or the insert row. The updater methods do not
1762: * update the underlying database; instead the <code>updateRow</code> or
1763: * <code>insertRow</code> methods are called to update the database.
1764: *
1765: * @param columnName the name of the column
1766: * @param x the new column value
1767: * @exception SQLException if a database access error occurs
1768: */
1769: public void updateInt(String columnName, int x) throws SQLException {
1770: throw new UnsupportedOperationException(
1771: "ResultSet.updateInt(String, int) unsupported");
1772: }
1773:
1774: /**
1775: * Updates the designated column with a <code>long</code> value.
1776: * The updater methods are used to update column values in the
1777: * current row or the insert row. The updater methods do not
1778: * update the underlying database; instead the <code>updateRow</code> or
1779: * <code>insertRow</code> methods are called to update the database.
1780: *
1781: * @param columnName the name of the column
1782: * @param x the new column value
1783: * @exception SQLException if a database access error occurs
1784: */
1785: public void updateLong(String columnName, long x)
1786: throws SQLException {
1787: throw new UnsupportedOperationException(
1788: "ResultSet.updateLong(String, long) unsupported");
1789: }
1790:
1791: /**
1792: * Updates the designated column with a <code>float </code> value.
1793: * The updater methods are used to update column values in the
1794: * current row or the insert row. The updater methods do not
1795: * update the underlying database; instead the <code>updateRow</code> or
1796: * <code>insertRow</code> methods are called to update the database.
1797: *
1798: * @param columnName the name of the column
1799: * @param x the new column value
1800: * @exception SQLException if a database access error occurs
1801: */
1802: public void updateFloat(String columnName, float x)
1803: throws SQLException {
1804: throw new UnsupportedOperationException(
1805: "ResultSet.updateFloat(String, float) unsupported");
1806: }
1807:
1808: /**
1809: * Updates the designated column with a <code>double</code> value.
1810: * The updater methods are used to update column values in the
1811: * current row or the insert row. The updater methods do not
1812: * update the underlying database; instead the <code>updateRow</code> or
1813: * <code>insertRow</code> methods are called to update the database.
1814: *
1815: * @param columnName the name of the column
1816: * @param x the new column value
1817: * @exception SQLException if a database access error occurs
1818: */
1819: public void updateDouble(String columnName, double x)
1820: throws SQLException {
1821: throw new UnsupportedOperationException(
1822: "ResultSet.updateDouble(String, double) unsupported");
1823: }
1824:
1825: /**
1826: * Updates the designated column with a <code>java.sql.BigDecimal</code>
1827: * value.
1828: * The updater methods are used to update column values in the
1829: * current row or the insert row. The updater methods do not
1830: * update the underlying database; instead the <code>updateRow</code> or
1831: * <code>insertRow</code> methods are called to update the database.
1832: *
1833: * @param columnName the name of the column
1834: * @param x the new column value
1835: * @exception SQLException if a database access error occurs
1836: */
1837: public void updateBigDecimal(String columnName, BigDecimal x)
1838: throws SQLException {
1839: throw new UnsupportedOperationException(
1840: "ResultSet.updateBigDecimal(String, BigDecimal) unsupported");
1841: }
1842:
1843: /**
1844: * Updates the designated column with a <code>String</code> value.
1845: * The updater methods are used to update column values in the
1846: * current row or the insert row. The updater methods do not
1847: * update the underlying database; instead the <code>updateRow</code> or
1848: * <code>insertRow</code> methods are called to update the database.
1849: *
1850: * @param columnName the name of the column
1851: * @param x the new column value
1852: * @exception SQLException if a database access error occurs
1853: */
1854: public void updateString(String columnName, String x)
1855: throws SQLException {
1856: throw new UnsupportedOperationException(
1857: "ResultSet.updateString(String, String) unsupported");
1858: }
1859:
1860: /**
1861: * Updates the designated column with a byte array value.
1862: *
1863: * The updater methods are used to update column values in the
1864: * current row or the insert row. The updater methods do not
1865: * update the underlying database; instead the <code>updateRow</code>
1866: * or <code>insertRow</code> methods are called to update the database.
1867: *
1868: * @param columnName the name of the column
1869: * @param x the new column value
1870: * @exception SQLException if a database access error occurs
1871: */
1872: public void updateBytes(String columnName, byte[] x)
1873: throws SQLException {
1874: throw new UnsupportedOperationException(
1875: "ResultSet.updateBytes(String, byte[]) unsupported");
1876: }
1877:
1878: /**
1879: * Updates the designated column with a <code>java.sql.Date</code> value.
1880: * The updater methods are used to update column values in the
1881: * current row or the insert row. The updater methods do not
1882: * update the underlying database; instead the <code>updateRow</code> or
1883: * <code>insertRow</code> methods are called to update the database.
1884: *
1885: * @param columnName the name of the column
1886: * @param x the new column value
1887: * @exception SQLException if a database access error occurs
1888: */
1889: public void updateDate(String columnName, Date x)
1890: throws SQLException {
1891: throw new UnsupportedOperationException(
1892: "ResultSet.updateDate(String, Date) unsupported");
1893: }
1894:
1895: /**
1896: * Updates the designated column with a <code>java.sql.Time</code> value.
1897: * The updater methods are used to update column values in the
1898: * current row or the insert row. The updater methods do not
1899: * update the underlying database; instead the <code>updateRow</code> or
1900: * <code>insertRow</code> methods are called to update the database.
1901: *
1902: * @param columnName the name of the column
1903: * @param x the new column value
1904: * @exception SQLException if a database access error occurs
1905: */
1906: public void updateTime(String columnName, Time x)
1907: throws SQLException {
1908: throw new UnsupportedOperationException(
1909: "ResultSet.updateTime(String, Time) unsupported");
1910: }
1911:
1912: /**
1913: * Updates the designated column with a <code>java.sql.Timestamp</code>
1914: * value.
1915: * The updater methods are used to update column values in the
1916: * current row or the insert row. The updater methods do not
1917: * update the underlying database; instead the <code>updateRow</code> or
1918: * <code>insertRow</code> methods are called to update the database.
1919: *
1920: * @param columnName the name of the column
1921: * @param x the new column value
1922: * @exception SQLException if a database access error occurs
1923: */
1924: public void updateTimestamp(String columnName, Timestamp x)
1925: throws SQLException {
1926: throw new UnsupportedOperationException(
1927: "ResultSet.updateTimestamp(String, Timestamp) unsupported");
1928: }
1929:
1930: /**
1931: * Updates the designated column with an ascii stream value.
1932: * The updater methods are used to update column values in the
1933: * current row or the insert row. The updater methods do not
1934: * update the underlying database; instead the <code>updateRow</code> or
1935: * <code>insertRow</code> methods are called to update the database.
1936: *
1937: * @param columnName the name of the column
1938: * @param x the new column value
1939: * @param length the length of the stream
1940: * @exception SQLException if a database access error occurs
1941: */
1942: public void updateAsciiStream(String columnName, InputStream x,
1943: int length) throws SQLException {
1944: throw new UnsupportedOperationException(
1945: "ResultSet.updateAsciiStream"
1946: + "(String, InputStream, int) unsupported");
1947: }
1948:
1949: /**
1950: * Updates the designated column with a binary stream value.
1951: * The updater methods are used to update column values in the
1952: * current row or the insert row. The updater methods do not
1953: * update the underlying database; instead the <code>updateRow</code> or
1954: * <code>insertRow</code> methods are called to update the database.
1955: *
1956: * @param columnName the name of the column
1957: * @param x the new column value
1958: * @param length the length of the stream
1959: * @exception SQLException if a database access error occurs
1960: */
1961: public void updateBinaryStream(String columnName, InputStream x,
1962: int length) throws SQLException {
1963: throw new UnsupportedOperationException(
1964: "ResultSet.updateBinaryStream"
1965: + "(String, InputStream, int) unsupported");
1966: }
1967:
1968: /**
1969: * Updates the designated column with a character stream value.
1970: * The updater methods are used to update column values in the
1971: * current row or the insert row. The updater methods do not
1972: * update the underlying database; instead the <code>updateRow</code> or
1973: * <code>insertRow</code> methods are called to update the database.
1974: *
1975: * @param columnName the name of the column
1976: * @param reader the <code>java.io.Reader</code> object containing
1977: * the new column value
1978: * @param length the length of the stream
1979: * @exception SQLException if a database access error occurs
1980: */
1981: public void updateCharacterStream(String columnName, Reader reader,
1982: int length) throws SQLException {
1983: throw new UnsupportedOperationException(
1984: "ResultSet.updateCharacterStr"
1985: + "eam(String, Reader, int) unsupported");
1986: }
1987:
1988: /**
1989: * Updates the designated column with an <code>Object</code> value.
1990: * The updater methods are used to update column values in the
1991: * current row or the insert row. The updater methods do not
1992: * update the underlying database; instead the <code>updateRow</code> or
1993: * <code>insertRow</code> methods are called to update the database.
1994: *
1995: * @param columnName the name of the column
1996: * @param x the new column value
1997: * @param scale for <code>java.sql.Types.DECIMAL</code>
1998: * or <code>java.sql.Types.NUMERIC</code> types,
1999: * this is the number of digits after the decimal point. For all other
2000: * types this value will be ignored.
2001: * @exception SQLException if a database access error occurs
2002: */
2003: public void updateObject(String columnName, Object x, int scale)
2004: throws SQLException {
2005: throw new UnsupportedOperationException(
2006: "ResultSet.updateObject(String, Object, int) unsupported");
2007: }
2008:
2009: /**
2010: * Updates the designated column with an <code>Object</code> value.
2011: * The updater methods are used to update column values in the
2012: * current row or the insert row. The updater methods do not
2013: * update the underlying database; instead the <code>updateRow</code> or
2014: * <code>insertRow</code> methods are called to update the database.
2015: *
2016: * @param columnName the name of the column
2017: * @param x the new column value
2018: * @exception SQLException if a database access error occurs
2019: */
2020: public void updateObject(String columnName, Object x)
2021: throws SQLException {
2022: throw new UnsupportedOperationException(
2023: "ResultSet.updateObject(String, Object) unsupported");
2024: }
2025:
2026: /**
2027: * Inserts the contents of the insert row into this
2028: * <code>ResultSet</code> object and into the database.
2029: * The cursor must be on the insert row when this method is called.
2030: *
2031: * @exception SQLException if a database access error occurs,
2032: * if this method is called when the cursor is not on the insert row,
2033: * or if not all of non-nullable columns in
2034: * the insert row have been given a value
2035: */
2036: public void insertRow() throws SQLException {
2037: throw new UnsupportedOperationException(
2038: "ResultSet.insertRow() unsupported");
2039: }
2040:
2041: /**
2042: * Updates the underlying database with the new contents of the
2043: * current row of this <code>ResultSet</code> object.
2044: * This method cannot be called when the cursor is on the insert row.
2045: *
2046: * @exception SQLException if a database access error occurs or
2047: * if this method is called when the cursor is on the insert row
2048: */
2049: public void updateRow() throws SQLException {
2050: throw new UnsupportedOperationException(
2051: "ResultSet.updateRow() unsupported");
2052: }
2053:
2054: /**
2055: * Deletes the current row from this <code>ResultSet</code> object
2056: * and from the underlying database. This method cannot be called when
2057: * the cursor is on the insert row.
2058: *
2059: * @exception SQLException if a database access error occurs
2060: * or if this method is called when the cursor is on the insert row
2061: */
2062: public void deleteRow() throws SQLException {
2063: throw new UnsupportedOperationException(
2064: "ResultSet.deleteRow() unsupported");
2065: }
2066:
2067: /**
2068: * Refreshes the current row with its most recent value in
2069: * the database. This method cannot be called when
2070: * the cursor is on the insert row.
2071: *
2072: * <P>The <code>refreshRow</code> method provides a way for an
2073: * application to
2074: * explicitly tell the JDBC driver to refetch a row(s) from the
2075: * database. An application may want to call <code>refreshRow</code> when
2076: * caching or prefetching is being done by the JDBC driver to
2077: * fetch the latest value of a row from the database. The JDBC driver
2078: * may actually refresh multiple rows at once if the fetch size is
2079: * greater than one.
2080: *
2081: * <P> All values are refetched subject to the transaction isolation
2082: * level and cursor sensitivity. If <code>refreshRow</code> is called after
2083: * calling an updater method, but before calling
2084: * the method <code>updateRow</code>, then the
2085: * updates made to the row are lost. Calling the method
2086: * <code>refreshRow</code> frequently will likely slow performance.
2087: *
2088: * @exception SQLException if a database access error
2089: * occurs or if this method is called when the cursor is on the insert row
2090: */
2091: public void refreshRow() throws SQLException {
2092: throw new UnsupportedOperationException(
2093: "ResultSet.refreshRow() unsupported");
2094: }
2095:
2096: /**
2097: * Cancels the updates made to the current row in this
2098: * <code>ResultSet</code> object.
2099: * This method may be called after calling an
2100: * updater method(s) and before calling
2101: * the method <code>updateRow</code> to roll back
2102: * the updates made to a row. If no updates have been made or
2103: * <code>updateRow</code> has already been called, this method has no
2104: * effect.
2105: *
2106: * @exception SQLException if a database access error
2107: * occurs or if this method is called when the cursor is
2108: * on the insert row
2109: */
2110: public void cancelRowUpdates() throws SQLException {
2111: throw new UnsupportedOperationException(
2112: "ResultSet.cancelRowUpdates() unsupported");
2113: }
2114:
2115: /**
2116: * Moves the cursor to the insert row. The current cursor position is
2117: * remembered while the cursor is positioned on the insert row.
2118: *
2119: * The insert row is a special row associated with an updatable
2120: * result set. It is essentially a buffer where a new row may
2121: * be constructed by calling the updater methods prior to
2122: * inserting the row into the result set.
2123: *
2124: * Only the updater, getter,
2125: * and <code>insertRow</code> methods may be
2126: * called when the cursor is on the insert row. All of the columns in
2127: * a result set must be given a value each time this method is
2128: * called before calling <code>insertRow</code>.
2129: * An updater method must be called before a
2130: * getter method can be called on a column value.
2131: *
2132: * @exception SQLException if a database access error occurs
2133: * or the result set is not updatable
2134: */
2135: public void moveToInsertRow() throws SQLException {
2136: throw new UnsupportedOperationException(
2137: "ResultSet.moveToInsertRow() unsupported");
2138: }
2139:
2140: /**
2141: * Moves the cursor to the remembered cursor position, usually the
2142: * current row. This method has no effect if the cursor is not on
2143: * the insert row.
2144: *
2145: * @exception SQLException if a database access error occurs
2146: * or the result set is not updatable
2147: */
2148: public void moveToCurrentRow() throws SQLException {
2149: throw new UnsupportedOperationException(
2150: "ResultSet.moveToeCurrentRow() unsupported");
2151: }
2152:
2153: /**
2154: * Retrieves the <code>Statement</code> object that produced this
2155: * <code>ResultSet</code> object.
2156: * If the result set was generated some other way, such as by a
2157: * <code>DatabaseMetaData</code> method, this method returns
2158: * <code>null</code>.
2159: *
2160: * @return the <code>Statment</code> object that produced
2161: * this <code>ResultSet</code> object or <code>null</code>
2162: * if the result set was produced some other way
2163: * @exception SQLException if a database access error occurs
2164: */
2165: public Statement getStatement() throws SQLException {
2166: return statement;
2167: }
2168:
2169: /**
2170: * Retrieves the value of the designated column in the current row
2171: * of this <code>ResultSet</code> object as an <code>Object</code>
2172: * in the Java programming language.
2173: * If the value is an SQL <code>NULL</code>,
2174: * the driver returns a Java <code>null</code>.
2175: * This method uses the given <code>Map</code> object
2176: * for the custom mapping of the
2177: * SQL structured or distinct type that is being retrieved.
2178: *
2179: * @param i the first column is 1, the second is 2, ...
2180: * @param map a <code>java.util.Map</code> object that contains the mapping
2181: * from SQL type names to classes in the Java programming language
2182: * @return an <code>Object</code> in the Java programming language
2183: * representing the SQL value
2184: * @exception SQLException if a database access error occurs
2185: */
2186: public Object getObject(int i, Map map) throws SQLException {
2187: throw new UnsupportedOperationException(
2188: "ResultSet.getObject(int, Map) unsupported");
2189: }
2190:
2191: /**
2192: * Retrieves the value of the designated column in the current row
2193: * of this <code>ResultSet</code> object as a <code>Ref</code> object
2194: * in the Java programming language.
2195: *
2196: * @param i the first column is 1, the second is 2, ...
2197: * @return a <code>Ref</code> object representing an SQL <code>REF</code>
2198: * value
2199: * @exception SQLException if a database access error occurs
2200: */
2201: public Ref getRef(int i) throws SQLException {
2202: throw new UnsupportedOperationException(
2203: "ResultSet.getRef(int) unsupported");
2204: }
2205:
2206: /**
2207: * Retrieves the value of the designated column in the current row
2208: * of this <code>ResultSet</code> object as a <code>Blob</code> object
2209: * in the Java programming language.
2210: *
2211: * @param i the first column is 1, the second is 2, ...
2212: * @return a <code>Blob</code> object representing the SQL
2213: * <code>BLOB</code> value in the specified column
2214: * @exception SQLException if a database access error occurs
2215: */
2216: public Blob getBlob(int i) throws SQLException {
2217: throw new UnsupportedOperationException(
2218: "ResultSet.getBlob(int) unsupported");
2219: }
2220:
2221: /**
2222: * Retrieves the value of the designated column in the current row
2223: * of this <code>ResultSet</code> object as a <code>Clob</code> object
2224: * in the Java programming language.
2225: *
2226: * @param i the first column is 1, the second is 2, ...
2227: * @return a <code>Clob</code> object representing the SQL
2228: * <code>CLOB</code> value in the specified column
2229: * @exception SQLException if a database access error occurs
2230: */
2231: public Clob getClob(int i) throws SQLException {
2232: throw new UnsupportedOperationException(
2233: "ResultSet.getClob(int) unsupported");
2234: }
2235:
2236: /**
2237: * Retrieves the value of the designated column in the current row
2238: * of this <code>ResultSet</code> object as an <code>Array</code> object
2239: * in the Java programming language.
2240: *
2241: * @param i the first column is 1, the second is 2, ...
2242: * @return an <code>Array</code> object representing the SQL
2243: * <code>ARRAY</code> value in the specified column
2244: * @exception SQLException if a database access error occurs
2245: */
2246: public Array getArray(int i) throws SQLException {
2247: throw new UnsupportedOperationException(
2248: "ResultSet.getArray(int) unsupported");
2249: }
2250:
2251: /**
2252: * Retrieves the value of the designated column in the current row
2253: * of this <code>ResultSet</code> object as an <code>Object</code>
2254: * in the Java programming language.
2255: * If the value is an SQL <code>NULL</code>,
2256: * the driver returns a Java <code>null</code>.
2257: * This method uses the specified <code>Map</code> object for
2258: * custom mapping if appropriate.
2259: *
2260: * @param colName the name of the column from which to retrieve the value
2261: * @param map a <code>java.util.Map</code> object that contains the mapping
2262: * from SQL type names to classes in the Java programming language
2263: * @return an <code>Object</code> representing the SQL value in the
2264: * specified column
2265: * @exception SQLException if a database access error occurs
2266: */
2267: public Object getObject(String colName, Map map)
2268: throws SQLException {
2269: throw new UnsupportedOperationException(
2270: "ResultSet.getObject(String, Map) unsupported");
2271: }
2272:
2273: /**
2274: * Retrieves the value of the designated column in the current row
2275: * of this <code>ResultSet</code> object as a <code>Ref</code> object
2276: * in the Java programming language.
2277: *
2278: * @param colName the column name
2279: * @return a <code>Ref</code> object representing the SQL <code>REF</code>
2280: * value in the specified column
2281: * @exception SQLException if a database access error occurs
2282: */
2283: public Ref getRef(String colName) throws SQLException {
2284: throw new UnsupportedOperationException(
2285: "ResultSet.getRef(String) unsupported");
2286: }
2287:
2288: /**
2289: * Retrieves the value of the designated column in the current row
2290: * of this <code>ResultSet</code> object as a <code>Blob</code> object
2291: * in the Java programming language.
2292: *
2293: * @param colName the name of the column from which to retrieve the value
2294: * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
2295: * value in the specified column
2296: * @exception SQLException if a database access error occurs
2297: */
2298: public Blob getBlob(String colName) throws SQLException {
2299: throw new UnsupportedOperationException(
2300: "ResultSet.getBlob(String) unsupported");
2301: }
2302:
2303: /**
2304: * Retrieves the value of the designated column in the current row
2305: * of this <code>ResultSet</code> object as a <code>Clob</code> object
2306: * in the Java programming language.
2307: *
2308: * @param colName the name of the column from which to retrieve the value
2309: * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
2310: * value in the specified column
2311: * @exception SQLException if a database access error occurs
2312: */
2313: public Clob getClob(String colName) throws SQLException {
2314: throw new UnsupportedOperationException(
2315: "ResultSet.getClob(String) unsupported");
2316: }
2317:
2318: /**
2319: * Retrieves the value of the designated column in the current row
2320: * of this <code>ResultSet</code> object as an <code>Array</code> object
2321: * in the Java programming language.
2322: *
2323: * @param colName the name of the column from which to retrieve the value
2324: * @return an <code>Array</code> object representing the SQL
2325: * <code>ARRAY</code> value in the specified column
2326: * @exception SQLException if a database access error occurs
2327: */
2328: public Array getArray(String colName) throws SQLException {
2329: throw new UnsupportedOperationException(
2330: "ResultSet.getArray(String) unsupported");
2331: }
2332:
2333: /**
2334: * Retrieves the value of the designated column in the current row
2335: * of this <code>ResultSet</code> object as a <code>java.sql.Date</code>
2336: * object in the Java programming language.
2337: * This method uses the given calendar to construct an appropriate
2338: * millisecond value for the date if the underlying database does not store
2339: * timezone information.
2340: *
2341: * @param columnIndex the first column is 1, the second is 2, ...
2342: * @param cal the <code>java.util.Calendar</code> object
2343: * to use in constructing the date
2344: * @return the column value as a <code>java.sql.Date</code> object;
2345: * if the value is SQL <code>NULL</code>,
2346: * the value returned is <code>null</code> in the Java programming language
2347: * @exception SQLException if a database access error occurs
2348: */
2349: public Date getDate(int columnIndex, Calendar cal)
2350: throws SQLException {
2351: throw new UnsupportedOperationException(
2352: "ResultSet.getDate(int, Calendar) unsupported");
2353: }
2354:
2355: /**
2356: * Retrieves the value of the designated column in the current row
2357: * of this <code>ResultSet</code> object as a <code>java.sql.Date</code>
2358: * object in the Java programming language.
2359: * This method uses the given calendar to construct an appropriate
2360: * millisecond value for the date if the underlying database does not store
2361: * timezone information.
2362: *
2363: * @param columnName the SQL name of the column from which to retrieve the
2364: * value
2365: * @param cal the <code>java.util.Calendar</code> object
2366: * to use in constructing the date
2367: * @return the column value as a <code>java.sql.Date</code> object;
2368: * if the value is SQL <code>NULL</code>,
2369: * the value returned is <code>null</code> in the Java programming language
2370: * @exception SQLException if a database access error occurs
2371: */
2372: public Date getDate(String columnName, Calendar cal)
2373: throws SQLException {
2374: throw new UnsupportedOperationException(
2375: "ResultSet.getDate(String, Calendar) unsupported");
2376: }
2377:
2378: /**
2379: * Retrieves the value of the designated column in the current row
2380: * of this <code>ResultSet</code> object as a <code>java.sql.Time</code>
2381: * object in the Java programming language.
2382: * This method uses the given calendar to construct an appropriate
2383: * millisecond value for the time if the underlying database does not store
2384: * timezone information.
2385: *
2386: * @param columnIndex the first column is 1, the second is 2, ...
2387: * @param cal the <code>java.util.Calendar</code> object
2388: * to use in constructing the time
2389: * @return the column value as a <code>java.sql.Time</code> object;
2390: * if the value is SQL <code>NULL</code>,
2391: * the value returned is <code>null</code> in the Java programming language
2392: * @exception SQLException if a database access error occurs
2393: */
2394: public Time getTime(int columnIndex, Calendar cal)
2395: throws SQLException {
2396: throw new UnsupportedOperationException(
2397: "ResultSet.getTime(int, Calendar) unsupported");
2398: }
2399:
2400: /**
2401: * Retrieves the value of the designated column in the current row
2402: * of this <code>ResultSet</code> object as a <code>java.sql.Time</code>
2403: * object in the Java programming language.
2404: * This method uses the given calendar to construct an appropriate
2405: * millisecond value for the time if the underlying database does not store
2406: * timezone information.
2407: *
2408: * @param columnName the SQL name of the column
2409: * @param cal the <code>java.util.Calendar</code> object
2410: * to use in constructing the time
2411: * @return the column value as a <code>java.sql.Time</code> object;
2412: * if the value is SQL <code>NULL</code>,
2413: * the value returned is <code>null</code> in the Java programming language
2414: * @exception SQLException if a database access error occurs
2415: */
2416: public Time getTime(String columnName, Calendar cal)
2417: throws SQLException {
2418: throw new UnsupportedOperationException(
2419: "ResultSet.getTime(String, Calendar) unsupported");
2420: }
2421:
2422: /**
2423: * Retrieves the value of the designated column in the current row
2424: * of this <code>ResultSet</code> object as a
2425: * <code>java.sql.Timestamp</code> object in the Java programming language.
2426: * This method uses the given calendar to construct an appropriate
2427: * millisecond value for the timestamp if the underlying database does not
2428: * store timezone information.
2429: *
2430: * @param columnIndex the first column is 1, the second is 2, ...
2431: * @param cal the <code>java.util.Calendar</code> object
2432: * to use in constructing the timestamp
2433: * @return the column value as a <code>java.sql.Timestamp</code> object;
2434: * if the value is SQL <code>NULL</code>,
2435: * the value returned is <code>null</code> in the Java programming language
2436: * @exception SQLException if a database access error occurs
2437: */
2438: public Timestamp getTimestamp(int columnIndex, Calendar cal)
2439: throws SQLException {
2440: throw new UnsupportedOperationException(
2441: "ResultSet.getTimestamp(int, Calendar) unsupported");
2442: }
2443:
2444: /**
2445: * Retrieves the value of the designated column in the current row
2446: * of this <code>ResultSet</code> object as a <code>java.sql.Time</code>
2447: * object in the Java programming language.
2448: * This method uses the given calendar to construct an appropriate
2449: * millisecond value for the time if the underlying database does not store
2450: * timezone information.
2451: *
2452: * @param columnName the SQL name of the column
2453: * @param cal the <code>java.util.Calendar</code> object
2454: * to use in constructing the time
2455: * @return the column value as a <code>java.sql.Time</code> object;
2456: * if the value is SQL <code>NULL</code>,
2457: * the value returned is <code>null</code> in the Java programming language
2458: * @exception SQLException if a database access error occurs
2459: */
2460: public Timestamp getTimestamp(String columnName, Calendar cal)
2461: throws SQLException {
2462: throw new UnsupportedOperationException(
2463: "ResultSet.getTimestamp(String, Calendar) unsupported");
2464: }
2465:
2466: //---------------------------------------------------------------------
2467: // JDBC 3.0
2468: //---------------------------------------------------------------------
2469:
2470: public URL getURL(int columnIndex) throws SQLException {
2471: throw new UnsupportedOperationException(
2472: "ResultSet.getURL(int) unsupported");
2473: }
2474:
2475: public URL getURL(String columnName) throws SQLException {
2476: throw new UnsupportedOperationException(
2477: "ResultSet.getURL(String) unsupported");
2478: }
2479:
2480: public void updateRef(int columnIndex, Ref x) throws SQLException {
2481: throw new UnsupportedOperationException(
2482: "ResultSet.updateRef(int,java.sql.Ref) unsupported");
2483: }
2484:
2485: public void updateRef(String columnName, Ref x) throws SQLException {
2486: throw new UnsupportedOperationException(
2487: "ResultSet.updateRef(String,java.sql.Ref) unsupported");
2488: }
2489:
2490: public void updateBlob(int columnIndex, Blob x) throws SQLException {
2491: throw new UnsupportedOperationException(
2492: "ResultSet.updateBlob(int,java.sql.Blob) unsupported");
2493: }
2494:
2495: public void updateBlob(String columnName, Blob x)
2496: throws SQLException {
2497: throw new UnsupportedOperationException(
2498: "ResultSet.updateBlob(String,java.sql.Blob) unsupported");
2499: }
2500:
2501: public void updateClob(int columnIndex, Clob x) throws SQLException {
2502: throw new UnsupportedOperationException(
2503: "ResultSet.updateClob(int,java.sql.Clob) unsupported");
2504: }
2505:
2506: public void updateClob(String columnName, Clob x)
2507: throws SQLException {
2508: throw new UnsupportedOperationException(
2509: "ResultSet.updateClob(String,java.sql.Clob) unsupported");
2510: }
2511:
2512: public void updateArray(int columnIndex, Array x)
2513: throws SQLException {
2514: throw new UnsupportedOperationException(
2515: "ResultSet.updateArray(int,java.sql.Array) unsupported");
2516: }
2517:
2518: public void updateArray(String columnName, Array x)
2519: throws SQLException {
2520: throw new UnsupportedOperationException(
2521: "ResultSet.updateArray(String,java.sql.Array) unsupported");
2522: }
2523:
2524: public int getHoldability() throws SQLException {
2525: // TODO Auto-generated method stub
2526: return 0;
2527: }
2528:
2529: public Reader getNCharacterStream(int columnIndex)
2530: throws SQLException {
2531: // TODO Auto-generated method stub
2532: return null;
2533: }
2534:
2535: public Reader getNCharacterStream(String columnLabel)
2536: throws SQLException {
2537: // TODO Auto-generated method stub
2538: return null;
2539: }
2540:
2541: public NClob getNClob(int columnIndex) throws SQLException {
2542: // TODO Auto-generated method stub
2543: return null;
2544: }
2545:
2546: public NClob getNClob(String columnLabel) throws SQLException {
2547: // TODO Auto-generated method stub
2548: return null;
2549: }
2550:
2551: public String getNString(int columnIndex) throws SQLException {
2552: // TODO Auto-generated method stub
2553: return null;
2554: }
2555:
2556: public String getNString(String columnLabel) throws SQLException {
2557: // TODO Auto-generated method stub
2558: return null;
2559: }
2560:
2561: // public Object getObject(int arg0, Map<String, Class<?>> arg1) throws SQLException {
2562: // // TODO Auto-generated method stub
2563: // return null;
2564: // }
2565: //
2566: //
2567: // public Object getObject(String arg0, Map<String, Class<?>> arg1) throws SQLException
2568: // {
2569: // // TODO Auto-generated method stub
2570: // return null;
2571: // }
2572:
2573: public RowId getRowId(int columnIndex) throws SQLException {
2574: // TODO Auto-generated method stub
2575: return null;
2576: }
2577:
2578: public RowId getRowId(String columnLabel) throws SQLException {
2579: // TODO Auto-generated method stub
2580: return null;
2581: }
2582:
2583: public SQLXML getSQLXML(int columnIndex) throws SQLException {
2584: // TODO Auto-generated method stub
2585: return null;
2586: }
2587:
2588: public SQLXML getSQLXML(String columnLabel) throws SQLException {
2589: // TODO Auto-generated method stub
2590: return null;
2591: }
2592:
2593: public boolean isClosed() throws SQLException {
2594: // TODO Auto-generated method stub
2595: return false;
2596: }
2597:
2598: public void updateAsciiStream(int columnIndex, InputStream x)
2599: throws SQLException {
2600: // TODO Auto-generated method stub
2601: throw new UnsupportedOperationException(
2602: "ResultSet.updateAsciiStream(int,InputStream) unsupported");
2603: }
2604:
2605: public void updateAsciiStream(String columnLabel, InputStream x)
2606: throws SQLException {
2607: // TODO Auto-generated method stub
2608: throw new UnsupportedOperationException(
2609: "ResultSet.updateAsciiStream(String,InputStream) unsupported");
2610: }
2611:
2612: public void updateAsciiStream(int columnIndex, InputStream x,
2613: long length) throws SQLException {
2614: // TODO Auto-generated method stub
2615: throw new UnsupportedOperationException(
2616: "ResultSet.updateAsciiStream(int,InputStream,long) unsupported");
2617: }
2618:
2619: public void updateAsciiStream(String columnLabel, InputStream x,
2620: long length) throws SQLException {
2621: // TODO Auto-generated method stub
2622: throw new UnsupportedOperationException(
2623: "ResultSet.updateAsciiStream(String,InputStream,long) unsupported");
2624: }
2625:
2626: public void updateBinaryStream(int columnIndex, InputStream x)
2627: throws SQLException {
2628: // TODO Auto-generated method stub
2629: throw new UnsupportedOperationException(
2630: "ResultSet.updateBinaryStream(int,InputStream) unsupported");
2631: }
2632:
2633: public void updateBinaryStream(String columnLabel, InputStream x)
2634: throws SQLException {
2635: // TODO Auto-generated method stub
2636: throw new UnsupportedOperationException(
2637: "ResultSet.updateBinaryStream(String,InputStream) unsupported");
2638: }
2639:
2640: public void updateBinaryStream(int columnIndex, InputStream x,
2641: long length) throws SQLException {
2642: // TODO Auto-generated method stub
2643: throw new UnsupportedOperationException(
2644: "ResultSet.updateBinaryStream(int,InputStream,long) unsupported");
2645: }
2646:
2647: public void updateBinaryStream(String columnLabel, InputStream x,
2648: long length) throws SQLException {
2649: // TODO Auto-generated method stub
2650: throw new UnsupportedOperationException(
2651: "ResultSet.updateBinaryStream(String,InputStream,long) unsupported");
2652: }
2653:
2654: public void updateBlob(int columnIndex, InputStream inputStream)
2655: throws SQLException {
2656: // TODO Auto-generated method stub
2657: throw new UnsupportedOperationException(
2658: "ResultSet.updateBlob(int,InputStream) unsupported");
2659: }
2660:
2661: public void updateBlob(String columnLabel, InputStream inputStream)
2662: throws SQLException {
2663: // TODO Auto-generated method stub
2664: throw new UnsupportedOperationException(
2665: "ResultSet.updateBlob(String,InputStream) unsupported");
2666: }
2667:
2668: public void updateBlob(int columnIndex, InputStream inputStream,
2669: long length) throws SQLException {
2670: // TODO Auto-generated method stub
2671: throw new UnsupportedOperationException(
2672: "ResultSet.updateBlob(int,InputStream,long) unsupported");
2673: }
2674:
2675: public void updateBlob(String columnLabel, InputStream inputStream,
2676: long length) throws SQLException {
2677: // TODO Auto-generated method stub
2678: throw new UnsupportedOperationException(
2679: "ResultSet.updateBlob(String,InputStream,long) unsupported");
2680: }
2681:
2682: public void updateCharacterStream(int columnIndex, Reader x)
2683: throws SQLException {
2684: // TODO Auto-generated method stub
2685: throw new UnsupportedOperationException(
2686: "ResultSet.updateCharacterStream(int,Reader) unsupported");
2687: }
2688:
2689: public void updateCharacterStream(String columnLabel, Reader reader)
2690: throws SQLException {
2691: // TODO Auto-generated method stub
2692: throw new UnsupportedOperationException(
2693: "ResultSet.updateCharacterStream(String,Reader) unsupported");
2694: }
2695:
2696: public void updateCharacterStream(int columnIndex, Reader x,
2697: long length) throws SQLException {
2698: // TODO Auto-generated method stub
2699: throw new UnsupportedOperationException(
2700: "ResultSet.updateCharacterStream(int,Reader,long) unsupported");
2701: }
2702:
2703: public void updateCharacterStream(String columnLabel,
2704: Reader reader, long length) throws SQLException {
2705: // TODO Auto-generated method stub
2706: throw new UnsupportedOperationException(
2707: "ResultSet.updateCharacterStream(String,Reader,long) unsupported");
2708: }
2709:
2710: public void updateClob(int columnIndex, Reader reader)
2711: throws SQLException {
2712: // TODO Auto-generated method stub
2713: throw new UnsupportedOperationException(
2714: "ResultSet.updateClob(int,Reader) unsupported");
2715: }
2716:
2717: public void updateClob(String columnLabel, Reader reader)
2718: throws SQLException {
2719: // TODO Auto-generated method stub
2720: throw new UnsupportedOperationException(
2721: "ResultSet.updateClob(String,Reader) unsupported");
2722: }
2723:
2724: public void updateClob(int columnIndex, Reader reader, long length)
2725: throws SQLException {
2726: // TODO Auto-generated method stub
2727: throw new UnsupportedOperationException(
2728: "ResultSet.updateClob(int,Reader,long) unsupported");
2729: }
2730:
2731: public void updateClob(String columnLabel, Reader reader,
2732: long length) throws SQLException {
2733: // TODO Auto-generated method stub
2734: throw new UnsupportedOperationException(
2735: "ResultSet.updateClob(String,Reader,long) unsupported");
2736: }
2737:
2738: public void updateNCharacterStream(int columnIndex, Reader x)
2739: throws SQLException {
2740: // TODO Auto-generated method stub
2741: throw new UnsupportedOperationException(
2742: "ResultSet.updateNCharacterStream(int,Reader) unsupported");
2743: }
2744:
2745: public void updateNCharacterStream(String columnLabel, Reader reader)
2746: throws SQLException {
2747: // TODO Auto-generated method stub
2748: throw new UnsupportedOperationException(
2749: "ResultSet.updateNCharacterStream(String,Reader) unsupported");
2750: }
2751:
2752: public void updateNCharacterStream(int columnIndex, Reader x,
2753: long length) throws SQLException {
2754: // TODO Auto-generated method stub
2755: throw new UnsupportedOperationException(
2756: "ResultSet.updateNCharacterStream(int,Reader,long) unsupported");
2757: }
2758:
2759: public void updateNCharacterStream(String columnLabel,
2760: Reader reader, long length) throws SQLException {
2761: // TODO Auto-generated method stub
2762: throw new UnsupportedOperationException(
2763: "ResultSet.updateNCharacterStream(updateNCharacterStream,Reader,long) unsupported");
2764: }
2765:
2766: public void updateNClob(int columnIndex, NClob nClob)
2767: throws SQLException {
2768: // TODO Auto-generated method stub
2769: throw new UnsupportedOperationException(
2770: "ResultSet.updateNClob(int,NClob) unsupported");
2771: }
2772:
2773: public void updateNClob(String columnLabel, NClob nClob)
2774: throws SQLException {
2775: // TODO Auto-generated method stub
2776: throw new UnsupportedOperationException(
2777: "ResultSet.updateNClob(String,NClob) unsupported");
2778: }
2779:
2780: public void updateNClob(int columnIndex, Reader reader)
2781: throws SQLException {
2782: // TODO Auto-generated method stub
2783: throw new UnsupportedOperationException(
2784: "ResultSet.updateNClob(int,Reader) unsupported");
2785: }
2786:
2787: public void updateNClob(String columnLabel, Reader reader)
2788: throws SQLException {
2789: // TODO Auto-generated method stub
2790: throw new UnsupportedOperationException(
2791: "ResultSet.updateNClob(String,Reader) unsupported");
2792: }
2793:
2794: public void updateNClob(int columnIndex, Reader reader, long length)
2795: throws SQLException {
2796: // TODO Auto-generated method stub
2797: throw new UnsupportedOperationException(
2798: "ResultSet.updateNClob(int,Reader,long) unsupported");
2799: }
2800:
2801: public void updateNClob(String columnLabel, Reader reader,
2802: long length) throws SQLException {
2803: // TODO Auto-generated method stub
2804: throw new UnsupportedOperationException(
2805: "ResultSet.updateNClob(String,Reader,long) unsupported");
2806: }
2807:
2808: public void updateNString(int columnIndex, String nString)
2809: throws SQLException {
2810: // TODO Auto-generated method stub
2811: throw new UnsupportedOperationException(
2812: "ResultSet.updateNString(int,String) unsupported");
2813: }
2814:
2815: public void updateNString(String columnLabel, String nString)
2816: throws SQLException {
2817: // TODO Auto-generated method stub
2818: throw new UnsupportedOperationException(
2819: "ResultSet.updateNString(String,String) unsupported");
2820: }
2821:
2822: public void updateRowId(int columnIndex, RowId x)
2823: throws SQLException {
2824: // TODO Auto-generated method stub
2825: throw new UnsupportedOperationException(
2826: "ResultSet.updateRowId(int,RowId) unsupported");
2827: }
2828:
2829: public void updateRowId(String columnLabel, RowId x)
2830: throws SQLException {
2831: // TODO Auto-generated method stub
2832: throw new UnsupportedOperationException(
2833: "ResultSet.updateRowId(String,RowId) unsupported");
2834: }
2835:
2836: public void updateSQLXML(int columnIndex, SQLXML xmlObject)
2837: throws SQLException {
2838: // TODO Auto-generated method stub
2839: throw new UnsupportedOperationException(
2840: "ResultSet.updateSQLXML(int,String) unsupported");
2841: }
2842:
2843: public void updateSQLXML(String columnLabel, SQLXML xmlObject)
2844: throws SQLException {
2845: // TODO Auto-generated method stub
2846: throw new UnsupportedOperationException(
2847: "ResultSet.updateSQLXML(String,String) unsupported");
2848: }
2849:
2850: public boolean isWrapperFor(Class<?> iface) throws SQLException {
2851: // TODO Auto-generated method stub
2852: return false;
2853: }
2854:
2855: public <T> T unwrap(Class<T> iface) throws SQLException {
2856: // TODO Auto-generated method stub
2857: return null;
2858: }
2859:
2860: /////////////////////////////////////////////////
2861:
2862: }
|