0001: //
0002: // Copyright 1999 Craig Spannring
0003: //
0004: // All rights reserved.
0005: //
0006: // Redistribution and use in source and binary forms, with or without
0007: // modification, are permitted provided that the following conditions are met:
0008: // 1. Redistributions of source code must retain the above copyright
0009: // notice, this list of conditions and the following disclaimer.
0010: // 2. Redistributions in binary form must reproduce the above copyright
0011: // notice, this list of conditions and the following disclaimer in the
0012: // documentation and/or other materials provided with the distribution.
0013: // 3. All advertising materials mentioning features or use of this software
0014: // must display the following acknowledgement:
0015: // This product includes software developed by Craig Spannring
0016: // 4. The name of Craig Spannring may not be used to endorse or promote
0017: // products derived from this software without specific prior
0018: // written permission.
0019: //
0020: // THIS SOFTWARE IS PROVIDED BY CRAIG SPANNRING ``AS IS'' AND
0021: // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
0022: // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0023: // ARE DISCLAIMED. IN NO EVENT SHALL CRAIG SPANNRING BE LIABLE
0024: // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
0025: // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
0026: // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
0027: // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
0028: // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
0029: // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
0030: // SUCH DAMAGE.
0031: //
0032:
0033: package com.internetcds.jdbc.tds;
0034:
0035: import java.sql.*;
0036: import java.io.InputStream;
0037: import java.io.Reader;
0038: import java.math.BigDecimal;
0039: import java.util.Vector; // import java.util.Calendar;
0040: import java.util.GregorianCalendar;
0041: import java.util.Calendar;
0042: import java.util.Map;
0043: import java.net.URL;
0044:
0045: public class ResultSet_2_0 extends
0046: com.internetcds.jdbc.tds.ResultSet_base implements
0047: java.sql.ResultSet {
0048: public static final String cvsVersion = "$Id: ResultSet_2_0.java,v 1.1 2007-10-19 13:23:55 sinisa Exp $";
0049:
0050: public ResultSet_2_0(Tds tds_,
0051: com.internetcds.jdbc.tds.Statement stmt_, Columns columns_) {
0052: super (tds_, stmt_, columns_);
0053: }
0054:
0055: //---------------------------------------------------------------------
0056: // Getter's and Setter's
0057: //---------------------------------------------------------------------
0058:
0059: /**
0060: * JDBC 2.0
0061: *
0062: * <p>Gets the value of a column in the current row as a java.io.Reader.
0063: * @param columnIndex the first column is 1, the second is 2, ...
0064: */
0065: public java.io.Reader getCharacterStream(int columnIndex)
0066: throws SQLException {
0067: String val = getString(columnIndex);
0068: if (val == null)
0069: return null;
0070:
0071: return new java.io.StringReader(val);
0072: }
0073:
0074: /**
0075: * JDBC 2.0
0076: *
0077: * <p>Gets the value of a column in the current row as a java.io.Reader.
0078: * @param columnName the name of the column
0079: * @return the value in the specified column as a <code>java.io.Reader</code>
0080: */
0081: public java.io.Reader getCharacterStream(String columnName)
0082: throws SQLException {
0083: return getCharacterStream(findColumn(columnName));
0084: }
0085:
0086: /**
0087: * JDBC 2.0
0088: *
0089: * Gets the value of a column in the current row as a java.math.BigDecimal
0090: * object with full precision.
0091: *
0092: * @param columnIndex the first column is 1, the second is 2, ...
0093: * @return the column value (full precision); if the value is SQL NULL,
0094: * the result is null
0095: * @exception SQLException if a database access error occurs
0096: */
0097: public BigDecimal getBigDecimal(int columnIndex)
0098: throws SQLException {
0099: return getBigDecimal(columnIndex, 0);
0100: // NotImplemented();
0101: // return null;
0102: }
0103:
0104: /**
0105: * JDBC 2.0
0106: *
0107: * Gets the value of a column in the current row as a java.math.BigDecimal
0108: * object with full precision.
0109: * @param columnName the column name
0110: * @return the column value (full precision); if the value is SQL NULL,
0111: * the result is null
0112: * @exception SQLException if a database access error occurs
0113: *
0114: */
0115: public BigDecimal getBigDecimal(String columnName)
0116: throws SQLException {
0117:
0118: return getBigDecimal(findColumn(columnName), 0);
0119: // NotImplemented();
0120: // return null;
0121: }
0122:
0123: //---------------------------------------------------------------------
0124: // Traversal/Positioning
0125: //---------------------------------------------------------------------
0126:
0127: /**
0128: * JDBC 2.0
0129: *
0130: * <p>Indicates whether the cursor is before the first row in the result
0131: * set.
0132: *
0133: * @return true if the cursor is before the first row,
0134: * false otherwise. Returns
0135: * false when the result set contains no rows.
0136: * @exception SQLException if a database access error occurs
0137: */
0138: public boolean isBeforeFirst() throws SQLException {
0139: NotImplemented();
0140: return false;
0141: }
0142:
0143: /**
0144: * JDBC 2.0
0145: *
0146: * <p>Indicates whether the cursor is after the last row in the result
0147: * set.
0148: *
0149: * @return true if the cursor is after the last row, false otherwise. Returns
0150: * false when the result set contains no rows.
0151: * @exception SQLException if a database access error occurs
0152: */
0153: public boolean isAfterLast() throws SQLException {
0154: NotImplemented();
0155: return false;
0156: }
0157:
0158: /**
0159: * JDBC 2.0
0160: *
0161: * <p>Indicates whether the cursor is on the first row of the result set.
0162: *
0163: * @return true if the cursor is on the first row, false otherwise.
0164: * @exception SQLException if a database access error occurs
0165: */
0166: public boolean isFirst() throws SQLException {
0167: NotImplemented();
0168: return false;
0169: }
0170:
0171: /**
0172: * JDBC 2.0
0173: *
0174: * <p>Indicates whether the cursor is on the last row of the result set.
0175: * Note: Calling the method <code>isLast</code> may be expensive
0176: * because the JDBC driver
0177: * might need to fetch ahead one row in order to determine
0178: * whether the current row is the last row in the result set.
0179: *
0180: * @return true if the cursor is on the last row, false otherwise.
0181: * @exception SQLException if a database access error occurs
0182: */
0183: public boolean isLast() throws SQLException {
0184: NotImplemented();
0185: return false;
0186: }
0187:
0188: /**
0189: * JDBC 2.0
0190: *
0191: * <p>Moves the cursor to the front of the result set, just before the
0192: * first row. Has no effect if the result set contains no rows.
0193: *
0194: * @exception SQLException if a database access error occurs or the
0195: * result set type is TYPE_FORWARD_ONLY
0196: */
0197: public void beforeFirst() throws SQLException {
0198: NotImplemented();
0199: }
0200:
0201: /**
0202: * JDBC 2.0
0203: *
0204: * <p>Moves the cursor to the end of the result set, just after the last
0205: * row. Has no effect if the result set contains no rows.
0206: *
0207: * @exception SQLException if a database access error occurs or the
0208: * result set type is TYPE_FORWARD_ONLY
0209: */
0210: public void afterLast() throws SQLException {
0211: NotImplemented();
0212: }
0213:
0214: /**
0215: * JDBC 2.0
0216: *
0217: * <p>Moves the cursor to the first row in the result set.
0218: *
0219: * @return true if the cursor is on a valid row; false if
0220: * there are no rows in the result set
0221: * @exception SQLException if a database access error occurs or the
0222: * result set type is TYPE_FORWARD_ONLY
0223: */
0224: public boolean first() throws SQLException {
0225: NotImplemented();
0226: return false;
0227: }
0228:
0229: /**
0230: * JDBC 2.0
0231: *
0232: * <p>Moves the cursor to the last row in the result set.
0233: *
0234: * @return true if the cursor is on a valid row;
0235: * false if there are no rows in the result set
0236: * @exception SQLException if a database access error occurs or the
0237: * result set type is TYPE_FORWARD_ONLY.
0238: */
0239: public boolean last() throws SQLException {
0240: NotImplemented();
0241: return false;
0242: }
0243:
0244: /**
0245: * JDBC 2.0
0246: *
0247: * <p>Retrieves the current row number. The first row is number 1, the
0248: * second number 2, and so on.
0249: *
0250: * @return the current row number; 0 if there is no current row
0251: * @exception SQLException if a database access error occurs
0252: */
0253: public int getRow() throws SQLException {
0254: NotImplemented();
0255: return 0;
0256: }
0257:
0258: /**
0259: * JDBC 2.0
0260: *
0261: * <p>Moves the cursor to the given row number in the result set.
0262: *
0263: * <p>If the row number is positive, the cursor moves to
0264: * the given row number with respect to the
0265: * beginning of the result set. The first row is row 1, the second
0266: * is row 2, and so on.
0267: *
0268: * <p>If the given row number is negative, the cursor moves to
0269: * an absolute row position with respect to
0270: * the end of the result set. For example, calling
0271: * <code>absolute(-1)</code> positions the
0272: * cursor on the last row, <code>absolute(-2)</code> indicates the next-to-last
0273: * row, and so on.
0274: *
0275: * <p>An attempt to position the cursor beyond the first/last row in
0276: * the result set leaves the cursor before/after the first/last
0277: * row, respectively.
0278: *
0279: * <p>Note: Calling <code>absolute(1)</code> is the same
0280: * as calling <code>first()</code>.
0281: * Calling <code>absolute(-1)</code> is the same as calling <code>last()</code>.
0282: *
0283: * @return true if the cursor is on the result set; false otherwise
0284: * @exception SQLException if a database access error occurs or
0285: * row is 0, or result set type is TYPE_FORWARD_ONLY.
0286: */
0287: public boolean absolute(int row) throws SQLException {
0288: NotImplemented();
0289: return false;
0290: }
0291:
0292: /**
0293: * JDBC 2.0
0294: *
0295: * <p>Moves the cursor a relative number of rows, either positive or negative.
0296: * Attempting to move beyond the first/last row in the
0297: * result set positions the cursor before/after the
0298: * the first/last row. Calling <code>relative(0)</code> is valid, but does
0299: * not change the cursor position.
0300: *
0301: * <p>Note: Calling <code>relative(1)</code>
0302: * is different from calling <code>next()</code>
0303: * because is makes sense to call <code>next()</code> when there is no current row,
0304: * for example, when the cursor is positioned before the first row
0305: * or after the last row of the result set.
0306: *
0307: * @return true if the cursor is on a row; false otherwise
0308: * @exception SQLException if a database access error occurs, there
0309: * is no current row, or the result set type is TYPE_FORWARD_ONLY
0310: */
0311: public boolean relative(int rows) throws SQLException {
0312: NotImplemented();
0313: return false;
0314: }
0315:
0316: /**
0317: * JDBC 2.0
0318: *
0319: * <p>Moves the cursor to the previous row in the result set.
0320: *
0321: * <p>Note: <code>previous()</code> is not the same as
0322: * <code>relative(-1)</code> because it
0323: * makes sense to call</code>previous()</code> when there is no current row.
0324: *
0325: * @return true if the cursor is on a valid row; false if it is off the result set
0326: * @exception SQLException if a database access error occurs or the
0327: * result set type is TYPE_FORWARD_ONLY
0328: */
0329: public boolean previous() throws SQLException {
0330: NotImplemented();
0331: return false;
0332: }
0333:
0334: //---------------------------------------------------------------------
0335: // Properties
0336: //---------------------------------------------------------------------
0337:
0338: /**
0339: * JDBC 2.0
0340: *
0341: * The rows in a result set will be processed in a forward direction;
0342: * first-to-last.
0343: */
0344: int FETCH_FORWARD = 1000;
0345:
0346: /**
0347: * JDBC 2.0
0348: *
0349: * The rows in a result set will be processed in a reverse direction;
0350: * last-to-first.
0351: */
0352: int FETCH_REVERSE = 1001;
0353:
0354: /**
0355: * JDBC 2.0
0356: *
0357: * The order in which rows in a result set will be processed is unknown.
0358: */
0359: int FETCH_UNKNOWN = 1002;
0360:
0361: /**
0362: * JDBC 2.0
0363: *
0364: * Gives a hint as to the direction in which the rows in this result set
0365: * will be processed. The initial value is determined by the statement
0366: * that produced the result set. The fetch direction may be changed
0367: * at any time.
0368: *
0369: * @exception SQLException if a database access error occurs or
0370: * the result set type is TYPE_FORWARD_ONLY and the fetch direction is not
0371: * FETCH_FORWARD.
0372: */
0373: public void setFetchDirection(int direction) throws SQLException {
0374: NotImplemented();
0375: }
0376:
0377: /**
0378: * JDBC 2.0
0379: *
0380: * Returns the fetch direction for this result set.
0381: *
0382: * @return the current fetch direction for this result set
0383: * @exception SQLException if a database access error occurs
0384: */
0385: public int getFetchDirection() throws SQLException {
0386: NotImplemented();
0387: return 0;
0388: }
0389:
0390: /**
0391: * JDBC 2.0
0392: *
0393: * Gives the JDBC driver a hint as to the number of rows that should
0394: * be fetched from the database when more rows are needed for this result
0395: * set. If the fetch size specified is zero, the JDBC driver
0396: * ignores the value and is free to make its own best guess as to what
0397: * the fetch size should be. The default value is set by the statement
0398: * that created the result set. The fetch size may be changed at any
0399: * time.
0400: *
0401: * @param rows the number of rows to fetch
0402: * @exception SQLException if a database access error occurs or the
0403: * condition 0 <= rows <= this.getMaxRows() is not satisfied.
0404: */
0405: public void setFetchSize(int rows) throws SQLException {
0406: NotImplemented();
0407: }
0408:
0409: /**
0410: * JDBC 2.0
0411: *
0412: * Returns the fetch size for this result set.
0413: *
0414: * @return the current fetch size for this result set
0415: * @exception SQLException if a database access error occurs
0416: */
0417: public int getFetchSize() throws SQLException {
0418: NotImplemented();
0419: return 0;
0420: }
0421:
0422: /**
0423: * JDBC 2.0
0424: * The type for a <code>ResultSet</code> object whose cursor may
0425: * move only forward.
0426: */
0427: int TYPE_FORWARD_ONLY = 1003;
0428:
0429: /**
0430: * JDBC 2.0
0431: * The type for a <code>ResultSet</code> object that is scrollable
0432: * but generally not sensitive to changes made by others.
0433: *
0434: */
0435: int TYPE_SCROLL_INSENSITIVE = 1004;
0436:
0437: /**
0438: * JDBC 2.0
0439: * The type for a <code>ResultSet</code> object that is scrollable
0440: * and generally sensitive to changes made by others.
0441: */
0442: int TYPE_SCROLL_SENSITIVE = 1005;
0443:
0444: /**
0445: * JDBC 2.0
0446: *
0447: * Returns the type of this result set. The type is determined by
0448: * the statement that created the result set.
0449: *
0450: * @return TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, or
0451: * TYPE_SCROLL_SENSITIVE
0452: * @exception SQLException if a database access error occurs
0453: */
0454: public int getType() throws SQLException {
0455: NotImplemented();
0456: return 0;
0457: }
0458:
0459: /**
0460: * JDBC 2.0
0461: * The concurrency mode for a <code>ResultSet</code> object
0462: * that may NOT be updated.
0463: *
0464: */
0465: int CONCUR_READ_ONLY = 1007;
0466:
0467: /**
0468: * JDBC 2.0
0469: * The concurrency mode for a <code>ResultSet</code> object
0470: * that may be updated.
0471: *
0472: */
0473: int CONCUR_UPDATABLE = 1008;
0474:
0475: /**
0476: * JDBC 2.0
0477: *
0478: * Returns the concurrency mode of this result set. The concurrency
0479: * used is determined by the statement that created the result set.
0480: *
0481: * @return the concurrency type, CONCUR_READ_ONLY or CONCUR_UPDATABLE
0482: * @exception SQLException if a database access error occurs
0483: */
0484: public int getConcurrency() throws SQLException {
0485: NotImplemented();
0486: return 0;
0487: }
0488:
0489: //---------------------------------------------------------------------
0490: // Updates
0491: //---------------------------------------------------------------------
0492:
0493: /**
0494: * JDBC 2.0
0495: *
0496: * Indicates whether the current row has been updated. The value returned
0497: * depends on whether or not the result set can detect updates.
0498: *
0499: * @return true if the row has been visibly updated by the owner or
0500: * another, and updates are detected
0501: * @exception SQLException if a database access error occurs
0502: *
0503: * @see DatabaseMetaData#updatesAreDetected
0504: */
0505: public boolean rowUpdated() throws SQLException {
0506: NotImplemented();
0507: return false;
0508: }
0509:
0510: /**
0511: * JDBC 2.0
0512: *
0513: * Indicates whether the current row has had an insertion. The value returned
0514: * depends on whether or not the result set can detect visible inserts.
0515: *
0516: * @return true if a row has had an insertion and insertions are detected
0517: * @exception SQLException if a database access error occurs
0518: *
0519: * @see DatabaseMetaData#insertsAreDetected
0520: */
0521: public boolean rowInserted() throws SQLException {
0522: NotImplemented();
0523: return false;
0524: }
0525:
0526: /**
0527: * JDBC 2.0
0528: *
0529: * Indicates whether a row has been deleted. A deleted row may leave
0530: * a visible "hole" in a result set. This method can be used to
0531: * detect holes in a result set. The value returned depends on whether
0532: * or not the result set can detect deletions.
0533: *
0534: * @return true if a row was deleted and deletions are detected
0535: * @exception SQLException if a database access error occurs
0536: *
0537: * @see DatabaseMetaData#deletesAreDetected
0538: */
0539: public boolean rowDeleted() throws SQLException {
0540: NotImplemented();
0541: return false;
0542: }
0543:
0544: /**
0545: * JDBC 2.0
0546: *
0547: * Give a nullable column a null value.
0548: *
0549: * The <code>updateXXX</code> methods are used to update column values in the
0550: * current row, or the insert row. The <code>updateXXX</code> methods do not
0551: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0552: * methods are called to update the database.
0553: *
0554: * @param columnIndex the first column is 1, the second is 2, ...
0555: * @exception SQLException if a database access error occurs
0556: */
0557: public void updateNull(int columnIndex) throws SQLException {
0558: NotImplemented();
0559: }
0560:
0561: /**
0562: * JDBC 2.0
0563: *
0564: * Updates a column with a boolean value.
0565: *
0566: * The <code>updateXXX</code> methods are used to update column values in the
0567: * current row, or the insert row. The <code>updateXXX</code> methods do not
0568: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0569: * methods are called to update the database.
0570: *
0571: * @param columnIndex the first column is 1, the second is 2, ...
0572: * @param x the new column value
0573: * @exception SQLException if a database access error occurs
0574: */
0575: public void updateBoolean(int columnIndex, boolean x)
0576: throws SQLException {
0577: NotImplemented();
0578: }
0579:
0580: /**
0581: * JDBC 2.0
0582: *
0583: * Updates a column with a byte value.
0584: *
0585: * The <code>updateXXX</code> methods are used to update column values in the
0586: * current row, or the insert row. The <code>updateXXX</code> methods do not
0587: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0588: * methods are called to update the database.
0589: *
0590: * @param columnIndex the first column is 1, the second is 2, ...
0591: * @param x the new column value
0592: * @exception SQLException if a database access error occurs
0593: */
0594: public void updateByte(int columnIndex, byte x) throws SQLException {
0595: NotImplemented();
0596: }
0597:
0598: /**
0599: * JDBC 2.0
0600: *
0601: * Updates a column with a short value.
0602: *
0603: * The <code>updateXXX</code> methods are used to update column values in the
0604: * current row, or the insert row. The <code>updateXXX</code> methods do not
0605: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0606: * methods are called to update the database.
0607: *
0608: * @param columnIndex the first column is 1, the second is 2, ...
0609: * @param x the new column value
0610: * @exception SQLException if a database access error occurs
0611: */
0612: public void updateShort(int columnIndex, short x)
0613: throws SQLException {
0614: NotImplemented();
0615: }
0616:
0617: /**
0618: * JDBC 2.0
0619: *
0620: * Updates a column with an integer value.
0621: *
0622: * The <code>updateXXX</code> methods are used to update column values in the
0623: * current row, or the insert row. The <code>updateXXX</code> methods do not
0624: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0625: * methods are called to update the database.
0626: *
0627: * @param columnIndex the first column is 1, the second is 2, ...
0628: * @param x the new column value
0629: * @exception SQLException if a database access error occurs
0630: */
0631: public void updateInt(int columnIndex, int x) throws SQLException {
0632: NotImplemented();
0633: }
0634:
0635: /**
0636: * JDBC 2.0
0637: *
0638: * Updates a column with a long value.
0639: *
0640: * The <code>updateXXX</code> methods are used to update column values in the
0641: * current row, or the insert row. The <code>updateXXX</code> methods do not
0642: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0643: * methods are called to update the database.
0644: *
0645: * @param columnIndex the first column is 1, the second is 2, ...
0646: * @param x the new column value
0647: * @exception SQLException if a database access error occurs
0648: */
0649: public void updateLong(int columnIndex, long x) throws SQLException {
0650: NotImplemented();
0651: }
0652:
0653: /**
0654: * JDBC 2.0
0655: *
0656: * Updates a column with a float value.
0657: *
0658: * The <code>updateXXX</code> methods are used to update column values in the
0659: * current row, or the insert row. The <code>updateXXX</code> methods do not
0660: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0661: * methods are called to update the database.
0662: *
0663: * @param columnIndex the first column is 1, the second is 2, ...
0664: * @param x the new column value
0665: * @exception SQLException if a database access error occurs
0666: */
0667: public void updateFloat(int columnIndex, float x)
0668: throws SQLException {
0669: NotImplemented();
0670: }
0671:
0672: /**
0673: * JDBC 2.0
0674: *
0675: * Updates a column with a Double value.
0676: *
0677: * The <code>updateXXX</code> methods are used to update column values in the
0678: * current row, or the insert row. The <code>updateXXX</code> methods do not
0679: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0680: * methods are called to update the database.
0681: *
0682: * @param columnIndex the first column is 1, the second is 2, ...
0683: * @param x the new column value
0684: * @exception SQLException if a database access error occurs
0685: */
0686: public void updateDouble(int columnIndex, double x)
0687: throws SQLException {
0688: NotImplemented();
0689: }
0690:
0691: /**
0692: * JDBC 2.0
0693: *
0694: * Updates a column with a BigDecimal value.
0695: *
0696: * The <code>updateXXX</code> methods are used to update column values in the
0697: * current row, or the insert row. The <code>updateXXX</code> methods do not
0698: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0699: * methods are called to update the database.
0700: *
0701: * @param columnIndex the first column is 1, the second is 2, ...
0702: * @param x the new column value
0703: * @exception SQLException if a database access error occurs
0704: */
0705: public void updateBigDecimal(int columnIndex, BigDecimal x)
0706: throws SQLException {
0707: NotImplemented();
0708: }
0709:
0710: /**
0711: * JDBC 2.0
0712: *
0713: * Updates a column with a String value.
0714: *
0715: * The <code>updateXXX</code> methods are used to update column values in the
0716: * current row, or the insert row. The <code>updateXXX</code> methods do not
0717: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0718: * methods are called to update the database.
0719: *
0720: * @param columnIndex the first column is 1, the second is 2, ...
0721: * @param x the new column value
0722: * @exception SQLException if a database access error occurs
0723: */
0724: public void updateString(int columnIndex, String x)
0725: throws SQLException {
0726: NotImplemented();
0727: }
0728:
0729: /**
0730: * JDBC 2.0
0731: *
0732: * Updates a column with a byte array value.
0733: *
0734: * The <code>updateXXX</code> methods are used to update column values in the
0735: * current row, or the insert row. The <code>updateXXX</code> methods do not
0736: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0737: * methods are called to update the database.
0738: *
0739: * @param columnIndex the first column is 1, the second is 2, ...
0740: * @param x the new column value
0741: * @exception SQLException if a database access error occurs
0742: */
0743: public void updateBytes(int columnIndex, byte x[])
0744: throws SQLException {
0745: NotImplemented();
0746: }
0747:
0748: /**
0749: * JDBC 2.0
0750: *
0751: * Updates a column with a Date value.
0752: *
0753: * The <code>updateXXX</code> methods are used to update column values in the
0754: * current row, or the insert row. The <code>updateXXX</code> methods do not
0755: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0756: * methods are called to update the database.
0757: *
0758: * @param columnIndex the first column is 1, the second is 2, ...
0759: * @param x the new column value
0760: * @exception SQLException if a database access error occurs
0761: */
0762: public void updateDate(int columnIndex, java.sql.Date x)
0763: throws SQLException {
0764: NotImplemented();
0765: }
0766:
0767: /**
0768: * JDBC 2.0
0769: *
0770: * Updates a column with a Time value.
0771: *
0772: * The <code>updateXXX</code> methods are used to update column values in the
0773: * current row, or the insert row. The <code>updateXXX</code> methods do not
0774: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0775: * methods are called to update the database.
0776: *
0777: * @param columnIndex the first column is 1, the second is 2, ...
0778: * @param x the new column value
0779: * @exception SQLException if a database access error occurs
0780: */
0781: public void updateTime(int columnIndex, java.sql.Time x)
0782: throws SQLException {
0783: NotImplemented();
0784: }
0785:
0786: /**
0787: * JDBC 2.0
0788: *
0789: * Updates a column with a Timestamp value.
0790: *
0791: * The <code>updateXXX</code> methods are used to update column values in the
0792: * current row, or the insert row. The <code>updateXXX</code> methods do not
0793: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0794: * methods are called to update the database.
0795: *
0796: * @param columnIndex the first column is 1, the second is 2, ...
0797: * @param x the new column value
0798: * @exception SQLException if a database access error occurs
0799: */
0800: public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
0801: throws SQLException {
0802: NotImplemented();
0803: }
0804:
0805: /**
0806: * JDBC 2.0
0807: *
0808: * Updates a column with an ascii stream value.
0809: *
0810: * The <code>updateXXX</code> methods are used to update column values in the
0811: * current row, or the insert row. The <code>updateXXX</code> methods do not
0812: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0813: * methods are called to update the database.
0814: *
0815: * @param columnIndex the first column is 1, the second is 2, ...
0816: * @param x the new column value
0817: * @param length the length of the stream
0818: * @exception SQLException if a database access error occurs
0819: */
0820: public void updateAsciiStream(int columnIndex,
0821: java.io.InputStream x, int length) throws SQLException {
0822: NotImplemented();
0823: }
0824:
0825: /**
0826: * JDBC 2.0
0827: *
0828: * Updates a column with a binary stream value.
0829: *
0830: * The <code>updateXXX</code> methods are used to update column values in the
0831: * current row, or the insert row. The <code>updateXXX</code> methods do not
0832: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0833: * methods are called to update the database.
0834: *
0835: * @param columnIndex the first column is 1, the second is 2, ...
0836: * @param x the new column value
0837: * @param length the length of the stream
0838: * @exception SQLException if a database access error occurs
0839: */
0840: public void updateBinaryStream(int columnIndex,
0841: java.io.InputStream x, int length) throws SQLException {
0842: NotImplemented();
0843: }
0844:
0845: /**
0846: * JDBC 2.0
0847: *
0848: * Updates a column with a character stream value.
0849: *
0850: * The <code>updateXXX</code> methods are used to update column values in the
0851: * current row, or the insert row. The <code>updateXXX</code> methods do not
0852: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0853: * methods are called to update the database.
0854: *
0855: * @param columnIndex the first column is 1, the second is 2, ...
0856: * @param x the new column value
0857: * @param length the length of the stream
0858: * @exception SQLException if a database access error occurs
0859: */
0860: public void updateCharacterStream(int columnIndex,
0861: java.io.Reader x, int length) throws SQLException {
0862: NotImplemented();
0863: }
0864:
0865: /**
0866: * JDBC 2.0
0867: *
0868: * Updates a column with an Object value.
0869: *
0870: * The <code>updateXXX</code> methods are used to update column values in the
0871: * current row, or the insert row. The <code>updateXXX</code> methods do not
0872: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0873: * methods are called to update the database.
0874: *
0875: * @param columnIndex the first column is 1, the second is 2, ...
0876: * @param x the new column value
0877: * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
0878: * this is the number of digits after the decimal. For all other
0879: * types this value will be ignored.
0880: * @exception SQLException if a database access error occurs
0881: */
0882: public void updateObject(int columnIndex, Object x, int scale)
0883: throws SQLException {
0884: NotImplemented();
0885: }
0886:
0887: /**
0888: * JDBC 2.0
0889: *
0890: * Updates a column with an Object value.
0891: *
0892: * The <code>updateXXX</code> methods are used to update column values in the
0893: * current row, or the insert row. The <code>updateXXX</code> methods do not
0894: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0895: * methods are called to update the database.
0896: *
0897: * @param columnIndex the first column is 1, the second is 2, ...
0898: * @param x the new column value
0899: * @exception SQLException if a database access error occurs
0900: */
0901: public void updateObject(int columnIndex, Object x)
0902: throws SQLException {
0903: NotImplemented();
0904: }
0905:
0906: /**
0907: * JDBC 2.0
0908: *
0909: * Updates a column with a null value.
0910: *
0911: * The <code>updateXXX</code> methods are used to update column values in the
0912: * current row, or the insert row. The <code>updateXXX</code> methods do not
0913: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0914: * methods are called to update the database.
0915: *
0916: * @param columnName the name of the column
0917: * @exception SQLException if a database access error occurs
0918: */
0919: public void updateNull(String columnName) throws SQLException {
0920: NotImplemented();
0921: }
0922:
0923: /**
0924: * JDBC 2.0
0925: *
0926: * Updates a column with a boolean value.
0927: *
0928: * The <code>updateXXX</code> methods are used to update column values in the
0929: * current row, or the insert row. The <code>updateXXX</code> methods do not
0930: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0931: * methods are called to update the database.
0932: *
0933: * @param columnName the name of the column
0934: * @param x the new column value
0935: * @exception SQLException if a database access error occurs
0936: */
0937: public void updateBoolean(String columnName, boolean x)
0938: throws SQLException {
0939: NotImplemented();
0940: }
0941:
0942: /**
0943: * JDBC 2.0
0944: *
0945: * Updates a column with a byte value.
0946: *
0947: * The <code>updateXXX</code> methods are used to update column values in the
0948: * current row, or the insert row. The <code>updateXXX</code> methods do not
0949: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0950: * methods are called to update the database.
0951: *
0952: * @param columnName the name of the column
0953: * @param x the new column value
0954: * @exception SQLException if a database access error occurs
0955: */
0956: public void updateByte(String columnName, byte x)
0957: throws SQLException {
0958: NotImplemented();
0959: }
0960:
0961: /**
0962: * JDBC 2.0
0963: *
0964: * Updates a column with a short value.
0965: *
0966: * The <code>updateXXX</code> methods are used to update column values in the
0967: * current row, or the insert row. The <code>updateXXX</code> methods do not
0968: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0969: * methods are called to update the database.
0970: *
0971: * @param columnName the name of the column
0972: * @param x the new column value
0973: * @exception SQLException if a database access error occurs
0974: */
0975: public void updateShort(String columnName, short x)
0976: throws SQLException {
0977: NotImplemented();
0978: }
0979:
0980: /**
0981: * JDBC 2.0
0982: *
0983: * Updates a column with an integer value.
0984: *
0985: * The <code>updateXXX</code> methods are used to update column values in the
0986: * current row, or the insert row. The <code>updateXXX</code> methods do not
0987: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
0988: * methods are called to update the database.
0989: *
0990: * @param columnName the name of the column
0991: * @param x the new column value
0992: * @exception SQLException if a database access error occurs
0993: */
0994: public void updateInt(String columnName, int x) throws SQLException {
0995: NotImplemented();
0996: }
0997:
0998: /**
0999: * JDBC 2.0
1000: *
1001: * Updates a column with a long value.
1002: *
1003: * The <code>updateXXX</code> methods are used to update column values in the
1004: * current row, or the insert row. The <code>updateXXX</code> methods do not
1005: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1006: * methods are called to update the database.
1007: *
1008: * @param columnName the name of the column
1009: * @param x the new column value
1010: * @exception SQLException if a database access error occurs
1011: */
1012: public void updateLong(String columnName, long x)
1013: throws SQLException {
1014: NotImplemented();
1015: }
1016:
1017: /**
1018: * JDBC 2.0
1019: *
1020: * Updates a column with a float value.
1021: *
1022: * The <code>updateXXX</code> methods are used to update column values in the
1023: * current row, or the insert row. The <code>updateXXX</code> methods do not
1024: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1025: * methods are called to update the database.
1026: *
1027: * @param columnName the name of the column
1028: * @param x the new column value
1029: * @exception SQLException if a database access error occurs
1030: */
1031: public void updateFloat(String columnName, float x)
1032: throws SQLException {
1033: NotImplemented();
1034: }
1035:
1036: /**
1037: * JDBC 2.0
1038: *
1039: * Updates a column with a double value.
1040: *
1041: * The <code>updateXXX</code> methods are used to update column values in the
1042: * current row, or the insert row. The <code>updateXXX</code> methods do not
1043: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1044: * methods are called to update the database.
1045: *
1046: * @param columnName the name of the column
1047: * @param x the new column value
1048: * @exception SQLException if a database access error occurs
1049: */
1050: public void updateDouble(String columnName, double x)
1051: throws SQLException {
1052: NotImplemented();
1053: }
1054:
1055: /**
1056: * JDBC 2.0
1057: *
1058: * Updates a column with a BigDecimal value.
1059: *
1060: * The <code>updateXXX</code> methods are used to update column values in the
1061: * current row, or the insert row. The <code>updateXXX</code> methods do not
1062: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1063: * methods are called to update the database.
1064: *
1065: * @param columnName the name of the column
1066: * @param x the new column value
1067: * @exception SQLException if a database access error occurs
1068: */
1069: public void updateBigDecimal(String columnName, BigDecimal x)
1070: throws SQLException {
1071: NotImplemented();
1072: }
1073:
1074: /**
1075: * JDBC 2.0
1076: *
1077: * Updates a column with a String value.
1078: *
1079: * The <code>updateXXX</code> methods are used to update column values in the
1080: * current row, or the insert row. The <code>updateXXX</code> methods do not
1081: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1082: * methods are called to update the database.
1083: *
1084: * @param columnName the name of the column
1085: * @param x the new column value
1086: * @exception SQLException if a database access error occurs
1087: */
1088: public void updateString(String columnName, String x)
1089: throws SQLException {
1090: NotImplemented();
1091: }
1092:
1093: /**
1094: * JDBC 2.0
1095: *
1096: * Updates a column with a byte array value.
1097: *
1098: * The <code>updateXXX</code> methods are used to update column values in the
1099: * current row, or the insert row. The <code>updateXXX</code> methods do not
1100: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1101: * methods are called to update the database.
1102: *
1103: * @param columnName the name of the column
1104: * @param x the new column value
1105: * @exception SQLException if a database access error occurs
1106: */
1107: public void updateBytes(String columnName, byte x[])
1108: throws SQLException {
1109: NotImplemented();
1110: }
1111:
1112: /**
1113: * JDBC 2.0
1114: *
1115: * Updates a column with a Date value.
1116: *
1117: * The <code>updateXXX</code> methods are used to update column values in the
1118: * current row, or the insert row. The <code>updateXXX</code> methods do not
1119: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1120: * methods are called to update the database.
1121: *
1122: * @param columnName the name of the column
1123: * @param x the new column value
1124: * @exception SQLException if a database access error occurs
1125: */
1126: public void updateDate(String columnName, java.sql.Date x)
1127: throws SQLException {
1128: NotImplemented();
1129: }
1130:
1131: /**
1132: * JDBC 2.0
1133: *
1134: * Updates a column with a Time value.
1135: *
1136: * The <code>updateXXX</code> methods are used to update column values in the
1137: * current row, or the insert row. The <code>updateXXX</code> methods do not
1138: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1139: * methods are called to update the database.
1140: *
1141: * @param columnName the name of the column
1142: * @param x the new column value
1143: * @exception SQLException if a database access error occurs
1144: */
1145: public void updateTime(String columnName, java.sql.Time x)
1146: throws SQLException {
1147: NotImplemented();
1148: }
1149:
1150: /**
1151: * JDBC 2.0
1152: *
1153: * Updates a column with a Timestamp value.
1154: *
1155: * The <code>updateXXX</code> methods are used to update column values in the
1156: * current row, or the insert row. The <code>updateXXX</code> methods do not
1157: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1158: * methods are called to update the database.
1159: *
1160: * @param columnName the name of the column
1161: * @param x the new column value
1162: * @exception SQLException if a database access error occurs
1163: */
1164: public void updateTimestamp(String columnName, java.sql.Timestamp x)
1165: throws SQLException {
1166: NotImplemented();
1167: }
1168:
1169: /**
1170: * JDBC 2.0
1171: *
1172: * Updates a column with an ascii stream value.
1173: *
1174: * The <code>updateXXX</code> methods are used to update column values in the
1175: * current row, or the insert row. The <code>updateXXX</code> methods do not
1176: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1177: * methods are called to update the database.
1178: *
1179: * @param columnName the name of the column
1180: * @param x the new column value
1181: * @param length of the stream
1182: * @exception SQLException if a database access error occurs
1183: */
1184: public void updateAsciiStream(String columnName,
1185: java.io.InputStream x, int length) throws SQLException {
1186: NotImplemented();
1187: }
1188:
1189: /**
1190: * JDBC 2.0
1191: *
1192: * Updates a column with a binary stream value.
1193: *
1194: * The <code>updateXXX</code> methods are used to update column values in the
1195: * current row, or the insert row. The <code>updateXXX</code> methods do not
1196: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1197: * methods are called to update the database.
1198: *
1199: * @param columnName the name of the column
1200: * @param x the new column value
1201: * @param length of the stream
1202: * @exception SQLException if a database access error occurs
1203: */
1204: public void updateBinaryStream(String columnName,
1205: java.io.InputStream x, int length) throws SQLException {
1206: NotImplemented();
1207: }
1208:
1209: /**
1210: * JDBC 2.0
1211: *
1212: * Updates a column with a character stream value.
1213: *
1214: * The <code>updateXXX</code> methods are used to update column values in the
1215: * current row, or the insert row. The <code>updateXXX</code> methods do not
1216: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1217: * methods are called to update the database.
1218: *
1219: * @param columnName the name of the column
1220: * @param x the new column value
1221: * @param length of the stream
1222: * @exception SQLException if a database access error occurs
1223: */
1224: public void updateCharacterStream(String columnName,
1225: java.io.Reader reader, int length) throws SQLException {
1226: NotImplemented();
1227: }
1228:
1229: /**
1230: * JDBC 2.0
1231: *
1232: * Updates a column with an Object value.
1233: *
1234: * The <code>updateXXX</code> methods are used to update column values in the
1235: * current row, or the insert row. The <code>updateXXX</code> methods do not
1236: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1237: * methods are called to update the database.
1238: *
1239: * @param columnName the name of the column
1240: * @param x the new column value
1241: * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
1242: * this is the number of digits after the decimal. For all other
1243: * types this value will be ignored.
1244: * @exception SQLException if a database access error occurs
1245: */
1246: public void updateObject(String columnName, Object x, int scale)
1247: throws SQLException {
1248: NotImplemented();
1249: }
1250:
1251: /**
1252: * JDBC 2.0
1253: *
1254: * Updates a column with an Object value.
1255: *
1256: * The <code>updateXXX</code> methods are used to update column values in the
1257: * current row, or the insert row. The <code>updateXXX</code> methods do not
1258: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1259: * methods are called to update the database.
1260: *
1261: * @param columnName the name of the column
1262: * @param x the new column value
1263: * @exception SQLException if a database access error occurs
1264: */
1265: public void updateObject(String columnName, Object x)
1266: throws SQLException {
1267: NotImplemented();
1268: }
1269:
1270: /**
1271: * JDBC 2.0
1272: *
1273: * Inserts the contents of the insert row into the result set and
1274: * the database. Must be on the insert row when this method is called.
1275: *
1276: * @exception SQLException if a database access error occurs,
1277: * if called when not on the insert row, or if not all of non-nullable columns in
1278: * the insert row have been given a value
1279: */
1280: public void insertRow() throws SQLException {
1281: NotImplemented();
1282: }
1283:
1284: /**
1285: * JDBC 2.0
1286: *
1287: * Updates the underlying database with the new contents of the
1288: * current row. Cannot be called when on the insert row.
1289: *
1290: * @exception SQLException if a database access error occurs or
1291: * if called when on the insert row
1292: */
1293: public void updateRow() throws SQLException {
1294: NotImplemented();
1295: }
1296:
1297: /**
1298: * JDBC 2.0
1299: *
1300: * Deletes the current row from the result set and the underlying
1301: * database. Cannot be called when on the insert row.
1302: *
1303: * @exception SQLException if a database access error occurs or if
1304: * called when on the insert row.
1305: */
1306: public void deleteRow() throws SQLException {
1307: NotImplemented();
1308: }
1309:
1310: /**
1311: * JDBC 2.0
1312: *
1313: * Refreshes the current row with its most recent value in
1314: * the database. Cannot be called when on the insert row.
1315: *
1316: * The <code>refreshRow</code> method provides a way for an application to
1317: * explicitly tell the JDBC driver to refetch a row(s) from the
1318: * database. An application may want to call <code>refreshRow</code> when
1319: * caching or prefetching is being done by the JDBC driver to
1320: * fetch the latest value of a row from the database. The JDBC driver
1321: * may actually refresh multiple rows at once if the fetch size is
1322: * greater than one.
1323: *
1324: * All values are refetched subject to the transaction isolation
1325: * level and cursor sensitivity. If <code>refreshRow</code> is called after
1326: * calling <code>updateXXX</code>, but before calling <code>updateRow</code>, then the
1327: * updates made to the row are lost. Calling the method <code>refreshRow</code> frequently
1328: * will likely slow performance.
1329: *
1330: * @exception SQLException if a database access error occurs or if
1331: * called when on the insert row
1332: */
1333: public void refreshRow() throws SQLException {
1334: NotImplemented();
1335: }
1336:
1337: /**
1338: * JDBC 2.0
1339: *
1340: * Cancels the updates made to a row.
1341: * This method may be called after calling an
1342: * <code>updateXXX</code> method(s) and before calling <code>updateRow</code> to rollback
1343: * the updates made to a row. If no updates have been made or
1344: * <code>updateRow</code> has already been called, then this method has no
1345: * effect.
1346: *
1347: * @exception SQLException if a database access error occurs or if
1348: * called when on the insert row
1349: *
1350: */
1351: public void cancelRowUpdates() throws SQLException {
1352: NotImplemented();
1353: }
1354:
1355: /**
1356: * JDBC 2.0
1357: *
1358: * Moves the cursor to the insert row. The current cursor position is
1359: * remembered while the cursor is positioned on the insert row.
1360: *
1361: * The insert row is a special row associated with an updatable
1362: * result set. It is essentially a buffer where a new row may
1363: * be constructed by calling the <code>updateXXX</code> methods prior to
1364: * inserting the row into the result set.
1365: *
1366: * Only the <code>updateXXX</code>, <code>getXXX</code>,
1367: * and <code>insertRow</code> methods may be
1368: * called when the cursor is on the insert row. All of the columns in
1369: * a result set must be given a value each time this method is
1370: * called before calling <code>insertRow</code>.
1371: * The method <code>updateXXX</code> must be called before a
1372: * <code>getXXX</code> method can be called on a column value.
1373: *
1374: * @exception SQLException if a database access error occurs
1375: * or the result set is not updatable
1376: */
1377: public void moveToInsertRow() throws SQLException {
1378: NotImplemented();
1379: }
1380:
1381: /**
1382: * JDBC 2.0
1383: *
1384: * Moves the cursor to the remembered cursor position, usually the
1385: * current row. This method has no effect if the cursor is not on the insert
1386: * row.
1387: *
1388: * @exception SQLException if a database access error occurs
1389: * or the result set is not updatable
1390: */
1391: public void moveToCurrentRow() throws SQLException {
1392: NotImplemented();
1393: }
1394:
1395: /**
1396: * JDBC 2.0
1397: *
1398: * Returns the Statement that produced this <code>ResultSet</code> object.
1399: * If the result set was generated some other way, such as by a
1400: * <code>DatabaseMetaData</code> method, this method returns <code>null</code>.
1401: *
1402: * @return the Statment that produced the result set or
1403: * null if the result set was produced some other way
1404: * @exception SQLException if a database access error occurs
1405: */
1406: public java.sql.Statement getStatement() throws SQLException {
1407: return stmt;
1408: }
1409:
1410: /**
1411: * JDBC 2.0
1412: *
1413: * Returns the value of a column in the current row as a Java object.
1414: * This method uses the given <code>Map</code> object
1415: * for the custom mapping of the
1416: * SQL structured or distinct type that is being retrieved.
1417: *
1418: * @param i the first column is 1, the second is 2, ...
1419: * @param map the mapping from SQL type names to Java classes
1420: * @return an object representing the SQL value
1421: */
1422: public Object getObject(int i, java.util.Map map)
1423: throws SQLException {
1424: NotImplemented();
1425: return null;
1426: }
1427:
1428: /**
1429: * JDBC 2.0
1430: *
1431: * Gets a REF(<structured-type>) column value from the current row.
1432: *
1433: * @param i the first column is 1, the second is 2, ...
1434: * @return a <code>Ref</code> object representing an SQL REF value
1435: */
1436: public Ref getRef(int i) throws SQLException {
1437: NotImplemented();
1438: return null;
1439: }
1440:
1441: /**
1442: * JDBC 2.0
1443: *
1444: * Gets a BLOB value in the current row of this <code>ResultSet</code> object.
1445: *
1446: * @param i the first column is 1, the second is 2, ...
1447: * @return a <code>Blob</code> object representing the SQL BLOB value in
1448: * the specified column
1449: */
1450: public Blob getBlob(int i) throws SQLException {
1451: NotImplemented();
1452: return null;
1453: }
1454:
1455: /**
1456: * JDBC 2.0
1457: *
1458: * Gets a CLOB value in the current row of this <code>ResultSet</code> object.
1459: *
1460: * @param i the first column is 1, the second is 2, ...
1461: * @return a <code>Clob</code> object representing the SQL CLOB value in
1462: * the specified column
1463: */
1464: public Clob getClob(int i) throws SQLException {
1465: NotImplemented();
1466: return null;
1467: }
1468:
1469: /**
1470: * JDBC 2.0
1471: *
1472: * Gets an SQL ARRAY value from the current row of this <code>ResultSet</code> object.
1473: *
1474: * @param i the first column is 1, the second is 2, ...
1475: * @return an <code>Array</code> object representing the SQL ARRAY value in
1476: * the specified column
1477: */
1478: public Array getArray(int i) throws SQLException {
1479: NotImplemented();
1480: return null;
1481: }
1482:
1483: /**
1484: * JDBC 2.0
1485: *
1486: * Returns the value in the specified column as a Java object.
1487: * This method uses the specified <code>Map</code> object for
1488: * custom mapping if appropriate.
1489: *
1490: * @param colName the name of the column from which to retrieve the value
1491: * @param map the mapping from SQL type names to Java classes
1492: * @return an object representing the SQL value in the specified column
1493: */
1494: public Object getObject(String colName, java.util.Map map)
1495: throws SQLException {
1496: NotImplemented();
1497: return null;
1498: }
1499:
1500: /**
1501: * JDBC 2.0
1502: *
1503: * Gets a REF(<structured-type>) column value from the current row.
1504: *
1505: * @param colName the column name
1506: * @return a <code>Ref</code> object representing the SQL REF value in
1507: * the specified column
1508: */
1509: public Ref getRef(String colName) throws SQLException {
1510: NotImplemented();
1511: return null;
1512: }
1513:
1514: /**
1515: * JDBC 2.0
1516: *
1517: * Gets a BLOB value in the current row of this <code>ResultSet</code> object.
1518: *
1519: * @param colName the name of the column from which to retrieve the value
1520: * @return a <code>Blob</code> object representing the SQL BLOB value in
1521: * the specified column
1522: */
1523: public Blob getBlob(String colName) throws SQLException {
1524: NotImplemented();
1525: return null;
1526: }
1527:
1528: /**
1529: * JDBC 2.0
1530: *
1531: * Gets a CLOB value in the current row of this <code>ResultSet</code> object.
1532: *
1533: * @param colName the name of the column from which to retrieve the value
1534: * @return a <code>Clob</code> object representing the SQL CLOB value in
1535: * the specified column
1536: */
1537: public Clob getClob(String colName) throws SQLException {
1538: NotImplemented();
1539: return null;
1540: }
1541:
1542: /**
1543: * JDBC 2.0
1544: *
1545: * Gets an SQL ARRAY value in the current row of this <code>ResultSet</code> object.
1546: *
1547: * @param colName the name of the column from which to retrieve the value
1548: * @return an <code>Array</code> object representing the SQL ARRAY value in
1549: * the specified column
1550: */
1551: public Array getArray(String colName) throws SQLException {
1552: NotImplemented();
1553: return null;
1554: }
1555:
1556: /**
1557: * Gets the value of a column in the current row as a java.sql.Timestamp
1558: * object. This method uses the given calendar to construct an
1559: * appropriate millisecond value for the Timestamp if the underlying
1560: * database does not store timezone information.
1561: *
1562: * @param columnIndex the first column is 1, the second is 2, ...
1563: * @param cal the calendar to use in constructing the timestamp
1564: * @return the column value; if the value is SQL NULL, the result is null
1565: * @exception SQLException if a database access error occurs
1566: */
1567: public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
1568: throws SQLException {
1569: NotImplemented();
1570: return null;
1571: }
1572:
1573: /**
1574: * Gets the value of a column in the current row as a
1575: * java.sql.Timestamp object. This method uses the given calendar
1576: * to construct an appropriate millisecond value for the Timestamp
1577: * if the underlying database does not store timezone information.
1578: *
1579: * @param columnName the SQL name of the column
1580: * @param cal the calendar to use in constructing the timestamp
1581: * @return the column value; if the value is SQL NULL, the result is null
1582: * @exception SQLException if a database access error occurs
1583: */
1584: public java.sql.Timestamp getTimestamp(String columnName,
1585: Calendar cal) throws SQLException {
1586: NotImplemented();
1587: return null;
1588: }
1589:
1590: /**
1591: * JDBC 2.0
1592: *
1593: * Gets the value of a column in the current row as a
1594: * java.sql.Date object. This method uses the given calendar to
1595: * construct an appropriate millisecond value for the Date if the
1596: * underlying database does not store timezone information.
1597: *
1598: * @param columnIndex the first column is 1, the second is 2, ...
1599: * @param cal the calendar to use in constructing the date
1600: * @return the column value; if the value is SQL NULL, the result is null
1601: * @exception SQLException if a database access error occurs
1602: */
1603: public java.sql.Date getDate(int columnIndex, Calendar cal)
1604: throws SQLException {
1605: NotImplemented();
1606: return null;
1607: }
1608:
1609: /**
1610: * Gets the value of a column in the current row as a
1611: * java.sql.Date object. This method uses the given calendar to
1612: * construct an appropriate millisecond value for the Date, if the
1613: * underlying database does not store timezone information.
1614: *
1615: * @param columnName the SQL name of the column from which to retrieve the value
1616: * @param cal the calendar to use in constructing the date
1617: * @return the column value; if the value is SQL NULL, the result is null
1618: * @exception SQLException if a database access error occurs
1619: */
1620: public java.sql.Date getDate(String columnName, Calendar cal)
1621: throws SQLException {
1622: NotImplemented();
1623: return null;
1624: }
1625:
1626: /**
1627: * Gets the value of a column in the current row as a
1628: * java.sql.Time object. This method uses the given calendar to
1629: * construct an appropriate millisecond value for the Time if the
1630: * underlying database does not store timezone information.
1631: *
1632: * @param columnIndex the first column is 1, the second is 2, ...
1633: * @param cal the calendar to use in constructing the time
1634: * @return the column value; if the value is SQL NULL, the result is null
1635: * @exception SQLException if a database access error occurs
1636: */
1637: public java.sql.Time getTime(int columnIndex, Calendar cal)
1638: throws SQLException {
1639: NotImplemented();
1640: return null;
1641: }
1642:
1643: /**
1644: * Gets the value of a column in the current row as a java.sql.Time
1645: * object. This method uses the given calendar to construct an
1646: * appropriate millisecond
1647: * value for the Time if the underlying database does not store
1648: * timezone information.
1649: *
1650: * @param columnName the SQL name of the column
1651: * @param cal the calendar to use in constructing the time
1652: * @return the column value; if the value is SQL NULL, the result is null
1653: * @exception SQLException if a database access error occurs
1654: */
1655: public java.sql.Time getTime(String columnName, Calendar cal)
1656: throws SQLException {
1657: NotImplemented();
1658: return null;
1659: }
1660:
1661: //---------------------------------------------------------------------
1662: // JDBC 3.0
1663: //---------------------------------------------------------------------
1664:
1665: public URL getURL(int columnIndex) throws SQLException {
1666: throw new UnsupportedOperationException(
1667: "ResultSet.getURL(int) unsupported");
1668: }
1669:
1670: public URL getURL(String columnName) throws SQLException {
1671: throw new UnsupportedOperationException(
1672: "ResultSet.getURL(String) unsupported");
1673: }
1674:
1675: public void updateRef(int columnIndex, Ref x) throws SQLException {
1676: throw new UnsupportedOperationException(
1677: "ResultSet.updateRef(int,java.sql.Ref) unsupported");
1678: }
1679:
1680: public void updateRef(String columnName, Ref x) throws SQLException {
1681: throw new UnsupportedOperationException(
1682: "ResultSet.updateRef(String,java.sql.Ref) unsupported");
1683: }
1684:
1685: public void updateBlob(int columnIndex, Blob x) throws SQLException {
1686: throw new UnsupportedOperationException(
1687: "ResultSet.updateBlob(int,java.sql.Blob) unsupported");
1688: }
1689:
1690: public void updateBlob(String columnName, Blob x)
1691: throws SQLException {
1692: throw new UnsupportedOperationException(
1693: "ResultSet.updateBlob(String,java.sql.Blob) unsupported");
1694: }
1695:
1696: public void updateClob(int columnIndex, Clob x) throws SQLException {
1697: throw new UnsupportedOperationException(
1698: "ResultSet.updateClob(int,java.sql.Clob) unsupported");
1699: }
1700:
1701: public void updateClob(String columnName, Clob x)
1702: throws SQLException {
1703: throw new UnsupportedOperationException(
1704: "ResultSet.updateClob(String,java.sql.Clob) unsupported");
1705: }
1706:
1707: public void updateArray(int columnIndex, Array x)
1708: throws SQLException {
1709: throw new UnsupportedOperationException(
1710: "ResultSet.updateArray(int,java.sql.Array) unsupported");
1711: }
1712:
1713: public void updateArray(String columnName, Array x)
1714: throws SQLException {
1715: throw new UnsupportedOperationException(
1716: "ResultSet.updateArray(String,java.sql.Array) unsupported");
1717: }
1718:
1719: public int getHoldability() throws SQLException {
1720: // TODO Auto-generated method stub
1721: return 0;
1722: }
1723:
1724: public Reader getNCharacterStream(int columnIndex)
1725: throws SQLException {
1726: // TODO Auto-generated method stub
1727: return null;
1728: }
1729:
1730: public Reader getNCharacterStream(String columnLabel)
1731: throws SQLException {
1732: // TODO Auto-generated method stub
1733: return null;
1734: }
1735:
1736: public NClob getNClob(int columnIndex) throws SQLException {
1737: // TODO Auto-generated method stub
1738: return null;
1739: }
1740:
1741: public NClob getNClob(String columnLabel) throws SQLException {
1742: // TODO Auto-generated method stub
1743: return null;
1744: }
1745:
1746: public String getNString(int columnIndex) throws SQLException {
1747: // TODO Auto-generated method stub
1748: return null;
1749: }
1750:
1751: public String getNString(String columnLabel) throws SQLException {
1752: // TODO Auto-generated method stub
1753: return null;
1754: }
1755:
1756: // public Object getObject(int arg0, Map<String, Class<?>> arg1) throws SQLException {
1757: // // TODO Auto-generated method stub
1758: // return null;
1759: // }
1760: //
1761: //
1762: // public Object getObject(String arg0, Map<String, Class<?>> arg1) throws SQLException {
1763: // // TODO Auto-generated method stub
1764: // return null;
1765: // }
1766:
1767: public RowId getRowId(int columnIndex) throws SQLException {
1768: // TODO Auto-generated method stub
1769: return null;
1770: }
1771:
1772: public RowId getRowId(String columnLabel) throws SQLException {
1773: // TODO Auto-generated method stub
1774: return null;
1775: }
1776:
1777: public SQLXML getSQLXML(int columnIndex) throws SQLException {
1778: // TODO Auto-generated method stub
1779: return null;
1780: }
1781:
1782: public SQLXML getSQLXML(String columnLabel) throws SQLException {
1783: // TODO Auto-generated method stub
1784: return null;
1785: }
1786:
1787: public boolean isClosed() throws SQLException {
1788: // TODO Auto-generated method stub
1789: return false;
1790: }
1791:
1792: public void updateAsciiStream(int columnIndex, InputStream x)
1793: throws SQLException {
1794: // TODO Auto-generated method stub
1795: throw new UnsupportedOperationException(
1796: "ResultSet.updateAsciiStream(int,InputStream) unsupported");
1797: }
1798:
1799: public void updateAsciiStream(String columnLabel, InputStream x)
1800: throws SQLException {
1801: // TODO Auto-generated method stub
1802: throw new UnsupportedOperationException(
1803: "ResultSet.updateAsciiStream(String,InputStream) unsupported");
1804: }
1805:
1806: public void updateAsciiStream(int columnIndex, InputStream x,
1807: long length) throws SQLException {
1808: // TODO Auto-generated method stub
1809: throw new UnsupportedOperationException(
1810: "ResultSet.updateAsciiStream(int,InputStream,long) unsupported");
1811: }
1812:
1813: public void updateAsciiStream(String columnLabel, InputStream x,
1814: long length) throws SQLException {
1815: // TODO Auto-generated method stub
1816: throw new UnsupportedOperationException(
1817: "ResultSet.updateAsciiStream(String,InputStream,long) unsupported");
1818: }
1819:
1820: public void updateBinaryStream(int columnIndex, InputStream x)
1821: throws SQLException {
1822: // TODO Auto-generated method stub
1823: throw new UnsupportedOperationException(
1824: "ResultSet.updateBinaryStream(int,InputStream) unsupported");
1825: }
1826:
1827: public void updateBinaryStream(String columnLabel, InputStream x)
1828: throws SQLException {
1829: // TODO Auto-generated method stub
1830: throw new UnsupportedOperationException(
1831: "ResultSet.updateBinaryStream(String,InputStream) unsupported");
1832: }
1833:
1834: public void updateBinaryStream(int columnIndex, InputStream x,
1835: long length) throws SQLException {
1836: // TODO Auto-generated method stub
1837: throw new UnsupportedOperationException(
1838: "ResultSet.updateBinaryStream(int,InputStream,long) unsupported");
1839: }
1840:
1841: public void updateBinaryStream(String columnLabel, InputStream x,
1842: long length) throws SQLException {
1843: // TODO Auto-generated method stub
1844: throw new UnsupportedOperationException(
1845: "ResultSet.updateBinaryStream(String,InputStream,long) unsupported");
1846: }
1847:
1848: public void updateBlob(int columnIndex, InputStream inputStream)
1849: throws SQLException {
1850: // TODO Auto-generated method stub
1851: throw new UnsupportedOperationException(
1852: "ResultSet.updateBlob(int,InputStream) unsupported");
1853: }
1854:
1855: public void updateBlob(String columnLabel, InputStream inputStream)
1856: throws SQLException {
1857: // TODO Auto-generated method stub
1858: throw new UnsupportedOperationException(
1859: "ResultSet.updateBlob(String,InputStream) unsupported");
1860: }
1861:
1862: public void updateBlob(int columnIndex, InputStream inputStream,
1863: long length) throws SQLException {
1864: // TODO Auto-generated method stub
1865: throw new UnsupportedOperationException(
1866: "ResultSet.updateBlob(int,InputStream,long) unsupported");
1867: }
1868:
1869: public void updateBlob(String columnLabel, InputStream inputStream,
1870: long length) throws SQLException {
1871: // TODO Auto-generated method stub
1872: throw new UnsupportedOperationException(
1873: "ResultSet.updateBlob(String,InputStream,long) unsupported");
1874: }
1875:
1876: public void updateCharacterStream(int columnIndex, Reader x)
1877: throws SQLException {
1878: // TODO Auto-generated method stub
1879: throw new UnsupportedOperationException(
1880: "ResultSet.updateCharacterStream(int,Reader) unsupported");
1881: }
1882:
1883: public void updateCharacterStream(String columnLabel, Reader reader)
1884: throws SQLException {
1885: // TODO Auto-generated method stub
1886: throw new UnsupportedOperationException(
1887: "ResultSet.updateCharacterStream(String,Reader) unsupported");
1888: }
1889:
1890: public void updateCharacterStream(int columnIndex, Reader x,
1891: long length) throws SQLException {
1892: // TODO Auto-generated method stub
1893: throw new UnsupportedOperationException(
1894: "ResultSet.updateCharacterStream(int,Reader,long) unsupported");
1895: }
1896:
1897: public void updateCharacterStream(String columnLabel,
1898: Reader reader, long length) throws SQLException {
1899: // TODO Auto-generated method stub
1900: throw new UnsupportedOperationException(
1901: "ResultSet.updateCharacterStream(String,Reader,long) unsupported");
1902: }
1903:
1904: public void updateClob(int columnIndex, Reader reader)
1905: throws SQLException {
1906: // TODO Auto-generated method stub
1907: throw new UnsupportedOperationException(
1908: "ResultSet.updateClob(int,Reader) unsupported");
1909: }
1910:
1911: public void updateClob(String columnLabel, Reader reader)
1912: throws SQLException {
1913: // TODO Auto-generated method stub
1914: throw new UnsupportedOperationException(
1915: "ResultSet.updateClob(String,Reader) unsupported");
1916: }
1917:
1918: public void updateClob(int columnIndex, Reader reader, long length)
1919: throws SQLException {
1920: // TODO Auto-generated method stub
1921: throw new UnsupportedOperationException(
1922: "ResultSet.updateClob(int,Reader,long) unsupported");
1923: }
1924:
1925: public void updateClob(String columnLabel, Reader reader,
1926: long length) throws SQLException {
1927: // TODO Auto-generated method stub
1928: throw new UnsupportedOperationException(
1929: "ResultSet.updateClob(String,Reader,long) unsupported");
1930: }
1931:
1932: public void updateNCharacterStream(int columnIndex, Reader x)
1933: throws SQLException {
1934: // TODO Auto-generated method stub
1935: throw new UnsupportedOperationException(
1936: "ResultSet.updateNCharacterStream(int,Reader) unsupported");
1937: }
1938:
1939: public void updateNCharacterStream(String columnLabel, Reader reader)
1940: throws SQLException {
1941: // TODO Auto-generated method stub
1942: throw new UnsupportedOperationException(
1943: "ResultSet.updateNCharacterStream(String,Reader) unsupported");
1944: }
1945:
1946: public void updateNCharacterStream(int columnIndex, Reader x,
1947: long length) throws SQLException {
1948: // TODO Auto-generated method stub
1949: throw new UnsupportedOperationException(
1950: "ResultSet.updateNCharacterStream(int,Reader,long) unsupported");
1951: }
1952:
1953: public void updateNCharacterStream(String columnLabel,
1954: Reader reader, long length) throws SQLException {
1955: // TODO Auto-generated method stub
1956: throw new UnsupportedOperationException(
1957: "ResultSet.updateNCharacterStream(String,Reader,long) unsupported");
1958: }
1959:
1960: public void updateNClob(int columnIndex, NClob nClob)
1961: throws SQLException {
1962: // TODO Auto-generated method stub
1963: throw new UnsupportedOperationException(
1964: "ResultSet.updateNClob(int,NClob) unsupported");
1965: }
1966:
1967: public void updateNClob(String columnLabel, NClob nClob)
1968: throws SQLException {
1969: // TODO Auto-generated method stub
1970: throw new UnsupportedOperationException(
1971: "ResultSet.updateNClob(String,NClob) unsupported");
1972: }
1973:
1974: public void updateNClob(int columnIndex, Reader reader)
1975: throws SQLException {
1976: // TODO Auto-generated method stub
1977: throw new UnsupportedOperationException(
1978: "ResultSet.updateNClob(int,Reader) unsupported");
1979: }
1980:
1981: public void updateNClob(String columnLabel, Reader reader)
1982: throws SQLException {
1983: // TODO Auto-generated method stub
1984: throw new UnsupportedOperationException(
1985: "ResultSet.updateNClob(String,Reader) unsupported");
1986: }
1987:
1988: public void updateNClob(int columnIndex, Reader reader, long length)
1989: throws SQLException {
1990: // TODO Auto-generated method stub
1991: throw new UnsupportedOperationException(
1992: "ResultSet.updateNClob(int,Reader,long) unsupported");
1993: }
1994:
1995: public void updateNClob(String columnLabel, Reader reader,
1996: long length) throws SQLException {
1997: // TODO Auto-generated method stub
1998: throw new UnsupportedOperationException(
1999: "ResultSet.updateNClob(String,Reader,long) unsupported");
2000: }
2001:
2002: public void updateNString(int columnIndex, String nString)
2003: throws SQLException {
2004: // TODO Auto-generated method stub
2005: throw new UnsupportedOperationException(
2006: "ResultSet.updateNString(int,String) unsupported");
2007: }
2008:
2009: public void updateNString(String columnLabel, String nString)
2010: throws SQLException {
2011: // TODO Auto-generated method stub
2012: throw new UnsupportedOperationException(
2013: "ResultSet.updateNString(String,String) unsupported");
2014: }
2015:
2016: public void updateRowId(int columnIndex, RowId x)
2017: throws SQLException {
2018: // TODO Auto-generated method stub
2019: throw new UnsupportedOperationException(
2020: "ResultSet.updateRowId(int,RowId) unsupported");
2021: }
2022:
2023: public void updateRowId(String columnLabel, RowId x)
2024: throws SQLException {
2025: // TODO Auto-generated method stub
2026: throw new UnsupportedOperationException(
2027: "ResultSet.updateRowId(String,RowId) unsupported");
2028: }
2029:
2030: public void updateSQLXML(int columnIndex, SQLXML xmlObject)
2031: throws SQLException {
2032: // TODO Auto-generated method stub
2033: throw new UnsupportedOperationException(
2034: "ResultSet.updateSQLXML(int,SQLXML) unsupported");
2035: }
2036:
2037: public void updateSQLXML(String columnLabel, SQLXML xmlObject)
2038: throws SQLException {
2039: // TODO Auto-generated method stub
2040: throw new UnsupportedOperationException(
2041: "ResultSet.updateSQLXML(String,SQLXML) unsupported");
2042: }
2043:
2044: public boolean isWrapperFor(Class<?> iface) throws SQLException {
2045: // TODO Auto-generated method stub
2046: return false;
2047: }
2048:
2049: public <T> T unwrap(Class<T> iface) throws SQLException {
2050: // TODO Auto-generated method stub
2051: return null;
2052: }
2053:
2054: }
|