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