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