0001: package org.mandarax.jdbc;
0002:
0003: /*
0004: * Copyright (C) 1999-2004 <a href="mailto:mandarax@jbdietrich.com">Jens Dietrich</a>
0005: *
0006: * This library is free software; you can redistribute it and/or
0007: * modify it under the terms of the GNU Lesser General Public
0008: * License as published by the Free Software Foundation; either
0009: * version 2 of the License, or (at your option) any later version.
0010: *
0011: * This library is distributed in the hope that it will be useful,
0012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0014: * Lesser General Public License for more details.
0015: *
0016: * You should have received a copy of the GNU Lesser General Public
0017: * License along with this library; if not, write to the Free Software
0018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0019: */
0020:
0021: import java.io.InputStream;
0022: import java.io.Reader;
0023: import java.math.BigDecimal;
0024: import java.net.URL;
0025: import java.sql.*;
0026: import java.util.*;
0027:
0028: /**
0029: * A simple read only result set implementation. All update related features are not supported -
0030: * a UnsupportedFeatureException will be thrown.
0031: * @author <A HREF="mailto:mandarax@jbdietrich.com">Jens Dietrich</A>
0032: * @version 3.3.2 <29 December 2004>
0033: * @since 3.0
0034: */
0035:
0036: public abstract class AbstractReadOnlyResultSet implements ResultSet {
0037:
0038: /**
0039: * Constructor.
0040: */
0041: public AbstractReadOnlyResultSet() {
0042: super ();
0043: }
0044:
0045: /**
0046: * Reports whether the last column read had a value of SQL NULL.
0047: * @return boolean
0048: * @throws java.sql.SQLException
0049: */
0050: public boolean wasNull() throws SQLException {
0051: return false;
0052: }
0053:
0054: /**
0055: * Retrieves the value of the designated column
0056: * in the current row of this ResultSet object as a String
0057: * in the Java programming language.
0058: * @param columnIndex
0059: * @return java.lang.String
0060: * @throws java.sql.SQLException
0061: */
0062: public String getString(int columnIndex) throws SQLException {
0063: Object obj = getObject(columnIndex);
0064: return obj == null ? null : obj.toString();
0065: }
0066:
0067: /**
0068: * Retrieves the value of the designated column in the current
0069: * row of this ResultSet object as a boolean in the Java programming
0070: * language.
0071: * @param columnIndex
0072: * @return boolean
0073: * @throws java.sql.SQLException
0074: */
0075: public boolean getBoolean(int columnIndex) throws SQLException {
0076: return ((Boolean) getObject(columnIndex)).booleanValue();
0077: }
0078:
0079: /**
0080: * Retrieves the value of the designated column in the current row
0081: * of this ResultSet object as a byte in the Java programming language.
0082: * @param columnIndex
0083: * @return byte
0084: * @throws java.sql.SQLException
0085: */
0086: public byte getByte(int columnIndex) throws SQLException {
0087: return ((Byte) getObject(columnIndex)).byteValue();
0088: }
0089:
0090: /**
0091: * Retrieves the value of the designated column in the current row
0092: * of this ResultSet object as a short in the Java programming language.
0093: * @param columnIndex
0094: * @return short
0095: * @throws java.sql.SQLException
0096: */
0097: public short getShort(int columnIndex) throws SQLException {
0098: return ((Short) getObject(columnIndex)).shortValue();
0099: }
0100:
0101: /**
0102: * Retrieves the value of the designated column in the current row
0103: * of this ResultSet object as an int in the Java programming language.
0104: * @param columnIndex
0105: * @return int
0106: * @throws java.sql.SQLException
0107: */
0108: public int getInt(int columnIndex) throws SQLException {
0109: return ((Integer) getObject(columnIndex)).intValue();
0110: }
0111:
0112: /**
0113: * Retrieves the value of the designated column in the current row
0114: * of this ResultSet object as a long in the Java programming language.
0115: * @param columnIndex
0116: * @return long
0117: * @throws java.sql.SQLException
0118: */
0119: public long getLong(int columnIndex) throws SQLException {
0120: return ((Long) getObject(columnIndex)).longValue();
0121: }
0122:
0123: /**
0124: * Retrieves the value of the designated column in the current row
0125: * of this ResultSet object as a float in the Java programming language.
0126: * @param columnIndex
0127: * @return float
0128: * @throws java.sql.SQLException
0129: */
0130: public float getFloat(int columnIndex) throws SQLException {
0131: return ((Float) getObject(columnIndex)).floatValue();
0132:
0133: }
0134:
0135: /**
0136: * Retrieves the value of the designated column in the current row
0137: * of this ResultSet object as a double in the Java programming language.
0138: * @param columnIndex
0139: * @return double
0140: * @throws java.sql.SQLException
0141: */
0142: public double getDouble(int columnIndex) throws SQLException {
0143: return ((Double) getObject(columnIndex)).doubleValue();
0144: }
0145:
0146: /**
0147: * Retrieves the value of the designated column in the current row of this ResultSet
0148: * object as a java.sql.BigDecimal in the Java programming language.
0149: * @param columnIndex
0150: * @param scale
0151: * @return java.math.BigDecimal
0152: * @throws java.sql.SQLException
0153: */
0154: public BigDecimal getBigDecimal(int columnIndex, int scale)
0155: throws SQLException {
0156: return (BigDecimal) getObject(columnIndex);
0157: }
0158:
0159: /**
0160: * Retrieves the value of the designated column in the current row
0161: * of this ResultSet object as a byte array in the Java programming
0162: * language. The bytes represent the raw values returned by the driver.
0163: * @param columnIndex
0164: * @return byte[]
0165: * @throws java.sql.SQLException
0166: */
0167: public byte[] getBytes(int columnIndex) throws SQLException {
0168: return (byte[]) getObject(columnIndex);
0169:
0170: }
0171:
0172: /**
0173: * Retrieves the value of the designated column in the current row
0174: * of this ResultSet object as a java.sql.Date object in the Java
0175: * programming language.
0176: * @param columnIndex
0177: * @return java.sql.Date
0178: * @throws java.sql.SQLException
0179: */
0180: public java.sql.Date getDate(int columnIndex) throws SQLException {
0181: return (java.sql.Date) getObject(columnIndex);
0182: }
0183:
0184: /**
0185: * Retrieves the value of the designated column in the current row
0186: * of this ResultSet object as a java.sql.Time object in the Java
0187: * programming language.
0188: * @param columnIndex
0189: * @return java.sql.Time
0190: * @throws java.sql.SQLException
0191: */
0192: public Time getTime(int columnIndex) throws SQLException {
0193: return (Time) getObject(columnIndex);
0194: }
0195:
0196: /**
0197: * Retrieves the value of the designated column in the current row
0198: * of this ResultSet object as a java.sql.Timestamp object in the
0199: * Java programming language.
0200: * @param columnIndex
0201: * @return java.sql.Timestamp
0202: * @throws java.sql.SQLException
0203: */
0204: public Timestamp getTimestamp(int columnIndex) throws SQLException {
0205: return (Timestamp) getObject(columnIndex);
0206: }
0207:
0208: /**
0209: * Retrieves the value of the designated column in the current row of this ResultSet
0210: * object as a stream of ASCII characters.
0211: * @param columnIndex
0212: * @return java.io.InputStream
0213: * @throws java.sql.SQLException
0214: */
0215: public InputStream getAsciiStream(int columnIndex)
0216: throws SQLException {
0217: return (InputStream) getObject(columnIndex);
0218: }
0219:
0220: /**
0221: * Retrieves the value of the designated column in the current row
0222: * of this ResultSet object as as a stream of two-byte Unicode characters.
0223: * @param columnIndex
0224: * @return java.io.InputStream
0225: * @throws java.sql.SQLException
0226: */
0227: public InputStream getUnicodeStream(int columnIndex)
0228: throws SQLException {
0229: return (InputStream) getObject(columnIndex);
0230: }
0231:
0232: /**
0233: * Retrieves the value of the designated column in the current row
0234: * of this ResultSet object as a binary stream of uninterpreted bytes.
0235: * @param columnIndex
0236: * @return java.io.InputStream
0237: * @throws java.sql.SQLException
0238: * @see java.sql.ResultSet#getBinaryStream(int)
0239: */
0240: public InputStream getBinaryStream(int columnIndex)
0241: throws SQLException {
0242: return (InputStream) getObject(columnIndex);
0243: }
0244:
0245: /**
0246: * Retrieves the value of the designated column in the current row of this
0247: * ResultSet object as a String in the Java programming language.
0248: * @param columnName
0249: * @return java.lang.String
0250: * @throws java.sql.SQLException
0251: * @see java.sql.ResultSet#getString(java.lang.String)
0252: */
0253: public String getString(String columnName) throws SQLException {
0254: return (String) getObject(columnName);
0255: }
0256:
0257: /**
0258: * Retrieves the value of the designated column in the current row
0259: * of this ResultSet object as a boolean in the Java programming language.
0260: * @param columnName
0261: * @return boolean
0262: * @throws java.sql.SQLException
0263: */
0264: public boolean getBoolean(String columnName) throws SQLException {
0265: return ((Boolean) getObject(columnName)).booleanValue();
0266: }
0267:
0268: /**
0269: * Retrieves the value of the designated column in the current row
0270: * of this ResultSet object as a byte in the Java programming language.
0271: * @param columnName
0272: * @return byte
0273: * @throws java.sql.SQLException
0274: */
0275: public byte getByte(String columnName) throws SQLException {
0276: return ((Byte) getObject(columnName)).byteValue();
0277: }
0278:
0279: /**
0280: * Retrieves the value of the designated column in the current row
0281: * of this ResultSet object as a short in the Java programming language.
0282: * @param columnName
0283: * @return short
0284: * @throws java.sql.SQLException
0285: */
0286: public short getShort(String columnName) throws SQLException {
0287: return ((Short) getObject(columnName)).shortValue();
0288: }
0289:
0290: /**
0291: * Retrieves the value of the designated column in the current row
0292: * of this ResultSet object as an int in the Java programming language.
0293: * @param columnName
0294: * @return int
0295: * @throws java.sql.SQLException
0296: */
0297: public int getInt(String columnName) throws SQLException {
0298: return ((Integer) getObject(columnName)).intValue();
0299:
0300: }
0301:
0302: /**
0303: * Retrieves the value of the designated column in the current row
0304: * of this ResultSet object as a long in the Java programming language.
0305: * @param columnName
0306: * @return long
0307: * @throws java.sql.SQLException
0308: */
0309: public long getLong(String columnName) throws SQLException {
0310: return ((Long) getObject(columnName)).longValue();
0311:
0312: }
0313:
0314: /**
0315: * Retrieves the value of the designated column in the current row
0316: * of this ResultSet object as a float in the Java programming language.
0317: * @param columnName
0318: * @return float
0319: * @throws java.sql.SQLException
0320: */
0321: public float getFloat(String columnName) throws SQLException {
0322: return ((Float) getObject(columnName)).floatValue();
0323: }
0324:
0325: /**
0326: * Retrieves the value of the designated column in the current row
0327: * of this ResultSet object as a double in the Java programming language.
0328: * @param columnName
0329: * @return double
0330: * @throws java.sql.SQLException
0331: */
0332: public double getDouble(String columnName) throws SQLException {
0333: return ((Double) getObject(columnName)).doubleValue();
0334: }
0335:
0336: /**
0337: * Retrieves the value of the designated column in the current row
0338: * of this ResultSet object as a java.math.BigDecimal in the Java programming language.
0339: * @param columnName
0340: * @param scale
0341: * @return java.math.BigDecimal
0342: * @throws java.sql.SQLException
0343: */
0344: public BigDecimal getBigDecimal(String columnName, int scale)
0345: throws SQLException {
0346: return (BigDecimal) getObject(columnName);
0347: }
0348:
0349: /**
0350: *
0351: * @param columnName
0352: * @return byte[]
0353: * @throws java.sql.SQLException
0354: * @see java.sql.ResultSet#getBytes(java.lang.String)
0355: */
0356: public byte[] getBytes(String columnName) throws SQLException {
0357: return (byte[]) getObject(columnName);
0358:
0359: }
0360:
0361: /**
0362: *
0363: * @param columnName
0364: * @return java.sql.Date
0365: * @throws java.sql.SQLException
0366: * @see java.sql.ResultSet#getDate(java.lang.String)
0367: */
0368: public java.sql.Date getDate(String columnName) throws SQLException {
0369: return (java.sql.Date) getObject(columnName);
0370: }
0371:
0372: /**
0373: *
0374: * @param columnName
0375: * @return java.sql.Time
0376: * @throws java.sql.SQLException
0377: * @see java.sql.ResultSet#getTime(java.lang.String)
0378: */
0379: public Time getTime(String columnName) throws SQLException {
0380: return (Time) getObject(columnName);
0381: }
0382:
0383: /**
0384: *
0385: * @param columnName
0386: * @return java.sql.Timestamp
0387: * @throws java.sql.SQLException
0388: * @see java.sql.ResultSet#getTimestamp(java.lang.String)
0389: */
0390: public Timestamp getTimestamp(String columnName)
0391: throws SQLException {
0392: return (Timestamp) getObject(columnName);
0393:
0394: }
0395:
0396: /**
0397: *
0398: * @param columnName
0399: * @return java.io.InputStream
0400: * @throws java.sql.SQLException
0401: * @see java.sql.ResultSet#getAsciiStream(java.lang.String)
0402: */
0403: public InputStream getAsciiStream(String columnName)
0404: throws SQLException {
0405: return (InputStream) getObject(columnName);
0406:
0407: }
0408:
0409: /**
0410: *
0411: * @param columnName
0412: * @return java.io.InputStream
0413: * @throws java.sql.SQLException
0414: * @see java.sql.ResultSet#getUnicodeStream(java.lang.String)
0415: */
0416: public InputStream getUnicodeStream(String columnName)
0417: throws SQLException {
0418: return (InputStream) getObject(columnName);
0419:
0420: }
0421:
0422: /**
0423: *
0424: * @param columnName
0425: * @return java.io.InputStream
0426: * @throws java.sql.SQLException
0427: * @see java.sql.ResultSet#getBinaryStream(java.lang.String)
0428: */
0429: public InputStream getBinaryStream(String columnName)
0430: throws SQLException {
0431: return (InputStream) getObject(columnName);
0432:
0433: }
0434:
0435: /**
0436: * Get the warnings. Not supported, return always null.
0437: * @return java.sql.SQLWarning
0438: * @throws java.sql.SQLException
0439: * @see java.sql.ResultSet#getWarnings()
0440: */
0441: public SQLWarning getWarnings() throws SQLException {
0442: return null;
0443:
0444: }
0445:
0446: /**
0447: * Clear the warnings.
0448: * @throws java.sql.SQLException
0449: * @see java.sql.ResultSet#clearWarnings()
0450: */
0451: public void clearWarnings() throws SQLException {
0452: // nothing to do
0453:
0454: }
0455:
0456: /**
0457: * Get the cursor name.
0458: * @return java.lang.String
0459: * @throws java.sql.SQLException
0460: * @see java.sql.ResultSet#getCursorName()
0461: */
0462: public String getCursorName() throws SQLException {
0463: throw new UnsupportedFeatureException(
0464: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0465: }
0466:
0467: /**
0468: *
0469: * @param columnIndex
0470: * @return java.io.Reader
0471: * @throws java.sql.SQLException
0472: * @see java.sql.ResultSet#getCharacterStream(int)
0473: */
0474: public Reader getCharacterStream(int columnIndex)
0475: throws SQLException {
0476: return (Reader) getObject(columnIndex);
0477:
0478: }
0479:
0480: /**
0481: *
0482: * @param columnName
0483: * @return java.io.Reader
0484: * @throws java.sql.SQLException
0485: * @see java.sql.ResultSet#getCharacterStream(java.lang.String)
0486: */
0487: public Reader getCharacterStream(String columnName)
0488: throws SQLException {
0489: return (Reader) getObject(columnName);
0490:
0491: }
0492:
0493: /**
0494: *
0495: * @param columnIndex
0496: * @return java.math.BigDecimal
0497: * @throws java.sql.SQLException
0498: * @see java.sql.ResultSet#getBigDecimal(int)
0499: */
0500: public BigDecimal getBigDecimal(int columnIndex)
0501: throws SQLException {
0502: return (BigDecimal) getObject(columnIndex);
0503:
0504: }
0505:
0506: /**
0507: *
0508: * @param columnName
0509: * @return java.math.BigDecimal
0510: * @throws java.sql.SQLException
0511: * @see java.sql.ResultSet#getBigDecimal(java.lang.String)
0512: */
0513: public BigDecimal getBigDecimal(String columnName)
0514: throws SQLException {
0515: return (BigDecimal) getObject(columnName);
0516:
0517: }
0518:
0519: /**
0520: * Set the fetch direction - currently ignored (does nothing, but does not throw an exception)
0521: * @param direction
0522: * @throws java.sql.SQLException
0523: * @see java.sql.ResultSet#setFetchDirection(int)
0524: */
0525: public void setFetchDirection(int direction) throws SQLException {
0526: // nothing to do
0527:
0528: }
0529:
0530: /**
0531: * Get the fetch direction.
0532: * @return int
0533: * @throws java.sql.SQLException
0534: * @see java.sql.ResultSet#getFetchDirection()
0535: */
0536: public int getFetchDirection() throws SQLException {
0537: return ResultSet.FETCH_FORWARD;
0538:
0539: }
0540:
0541: /**
0542: * Set the fetch size - currently ignored (does nothing, but does not throw an exception)
0543: * @param rows
0544: * @throws java.sql.SQLException
0545: * @see java.sql.ResultSet#setFetchSize(int)
0546: */
0547: public void setFetchSize(int rows) throws SQLException {
0548: // nothing to do
0549:
0550: }
0551:
0552: /**
0553: * Get the fetch size - currently always returns 1.
0554: * @return int
0555: * @throws java.sql.SQLException
0556: * @see java.sql.ResultSet#getFetchSize()
0557: */
0558: public int getFetchSize() throws SQLException {
0559: return 1;
0560:
0561: }
0562:
0563: /**
0564: *
0565: * @return int
0566: * @throws java.sql.SQLException
0567: * @see java.sql.ResultSet#getType()
0568: */
0569: public int getType() throws SQLException {
0570: return TYPE_SCROLL_INSENSITIVE;
0571:
0572: }
0573:
0574: /**
0575: *
0576: * @return int
0577: * @throws java.sql.SQLException
0578: * @see java.sql.ResultSet#getConcurrency()
0579: */
0580: public int getConcurrency() throws SQLException {
0581: throw new UnsupportedFeatureException(
0582: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0583:
0584: }
0585:
0586: /**
0587: *
0588: * @return boolean
0589: * @throws java.sql.SQLException
0590: * @see java.sql.ResultSet#rowUpdated()
0591: */
0592: public boolean rowUpdated() throws SQLException {
0593: throw new UnsupportedFeatureException(
0594: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0595:
0596: }
0597:
0598: /**
0599: *
0600: * @return boolean
0601: * @throws java.sql.SQLException
0602: * @see java.sql.ResultSet#rowInserted()
0603: */
0604: public boolean rowInserted() throws SQLException {
0605: throw new UnsupportedFeatureException(
0606: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0607:
0608: }
0609:
0610: /**
0611: *
0612: * @return boolean
0613: * @throws java.sql.SQLException
0614: * @see java.sql.ResultSet#rowDeleted()
0615: */
0616: public boolean rowDeleted() throws SQLException {
0617: throw new UnsupportedFeatureException(
0618: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0619:
0620: }
0621:
0622: /**
0623: *
0624: * @param columnIndex
0625: * @throws java.sql.SQLException
0626: * @see java.sql.ResultSet#updateNull(int)
0627: */
0628: public void updateNull(int columnIndex) throws SQLException {
0629: throw new UnsupportedFeatureException(
0630: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0631:
0632: }
0633:
0634: /**
0635: *
0636: * @param columnIndex
0637: * @param x
0638: * @throws java.sql.SQLException
0639: * @see java.sql.ResultSet#updateBoolean(int, boolean)
0640: */
0641: public void updateBoolean(int columnIndex, boolean x)
0642: throws SQLException {
0643: throw new UnsupportedFeatureException(
0644: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0645:
0646: }
0647:
0648: /**
0649: *
0650: * @param columnIndex
0651: * @param x
0652: * @throws java.sql.SQLException
0653: * @see java.sql.ResultSet#updateByte(int, byte)
0654: */
0655: public void updateByte(int columnIndex, byte x) throws SQLException {
0656: throw new UnsupportedFeatureException(
0657: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0658:
0659: }
0660:
0661: /**
0662: *
0663: * @param columnIndex
0664: * @param x
0665: * @throws java.sql.SQLException
0666: * @see java.sql.ResultSet#updateShort(int, short)
0667: */
0668: public void updateShort(int columnIndex, short x)
0669: throws SQLException {
0670: throw new UnsupportedFeatureException(
0671: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0672:
0673: }
0674:
0675: /**
0676: *
0677: * @param columnIndex
0678: * @param x
0679: * @throws java.sql.SQLException
0680: * @see java.sql.ResultSet#updateInt(int, int)
0681: */
0682: public void updateInt(int columnIndex, int x) throws SQLException {
0683: throw new UnsupportedFeatureException(
0684: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0685:
0686: }
0687:
0688: /**
0689: *
0690: * @param columnIndex
0691: * @param x
0692: * @throws java.sql.SQLException
0693: * @see java.sql.ResultSet#updateLong(int, long)
0694: */
0695: public void updateLong(int columnIndex, long x) throws SQLException {
0696: throw new UnsupportedFeatureException(
0697: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0698: }
0699:
0700: /**
0701: *
0702: * @param columnIndex
0703: * @param x
0704: * @throws java.sql.SQLException
0705: * @see java.sql.ResultSet#updateFloat(int, float)
0706: */
0707: public void updateFloat(int columnIndex, float x)
0708: throws SQLException {
0709: throw new UnsupportedFeatureException(
0710: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0711:
0712: }
0713:
0714: /**
0715: *
0716: * @param columnIndex
0717: * @param x
0718: * @throws java.sql.SQLException
0719: * @see java.sql.ResultSet#updateDouble(int, double)
0720: */
0721: public void updateDouble(int columnIndex, double x)
0722: throws SQLException {
0723: throw new UnsupportedFeatureException(
0724: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0725:
0726: }
0727:
0728: /**
0729: *
0730: * @param columnIndex
0731: * @param x
0732: * @throws java.sql.SQLException
0733: * @see java.sql.ResultSet#updateBigDecimal(int, java.math.BigDecimal)
0734: */
0735: public void updateBigDecimal(int columnIndex, BigDecimal x)
0736: throws SQLException {
0737: throw new UnsupportedFeatureException(
0738: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0739:
0740: }
0741:
0742: /**
0743: *
0744: * @param columnIndex
0745: * @param x
0746: * @throws java.sql.SQLException
0747: * @see java.sql.ResultSet#updateString(int, java.lang.String)
0748: */
0749: public void updateString(int columnIndex, String x)
0750: throws SQLException {
0751: throw new UnsupportedFeatureException(
0752: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0753:
0754: }
0755:
0756: /**
0757: *
0758: * @param columnIndex
0759: * @param x
0760: * @throws java.sql.SQLException
0761: * @see java.sql.ResultSet#updateBytes(int, byte[])
0762: */
0763: public void updateBytes(int columnIndex, byte[] x)
0764: throws SQLException {
0765: throw new UnsupportedFeatureException(
0766: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0767:
0768: }
0769:
0770: /**
0771: *
0772: * @param columnIndex
0773: * @param x
0774: * @throws java.sql.SQLException
0775: * @see java.sql.ResultSet#updateDate(int, java.sql.Date)
0776: */
0777: public void updateDate(int columnIndex, java.sql.Date x)
0778: throws SQLException {
0779: throw new UnsupportedFeatureException(
0780: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0781:
0782: }
0783:
0784: /**
0785: *
0786: * @param columnIndex
0787: * @param x
0788: * @throws java.sql.SQLException
0789: * @see java.sql.ResultSet#updateTime(int, java.sql.Time)
0790: */
0791: public void updateTime(int columnIndex, Time x) throws SQLException {
0792: throw new UnsupportedFeatureException(
0793: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0794:
0795: }
0796:
0797: /**
0798: *
0799: * @param columnIndex
0800: * @param x
0801: * @throws java.sql.SQLException
0802: * @see java.sql.ResultSet#updateTimestamp(int, java.sql.Timestamp)
0803: */
0804: public void updateTimestamp(int columnIndex, Timestamp x)
0805: throws SQLException {
0806: throw new UnsupportedFeatureException(
0807: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0808:
0809: }
0810:
0811: /**
0812: *
0813: * @param columnIndex
0814: * @param x
0815: * @param length
0816: * @throws java.sql.SQLException
0817: * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, int)
0818: */
0819: public void updateAsciiStream(int columnIndex, InputStream x,
0820: int length) throws SQLException {
0821: throw new UnsupportedFeatureException(
0822: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0823:
0824: }
0825:
0826: /**
0827: *
0828: * @param columnIndex
0829: * @param x
0830: * @param length
0831: * @throws java.sql.SQLException
0832: * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, int)
0833: */
0834: public void updateBinaryStream(int columnIndex, InputStream x,
0835: int length) throws SQLException {
0836: throw new UnsupportedFeatureException(
0837: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0838:
0839: }
0840:
0841: /**
0842: *
0843: * @param columnIndex
0844: * @param x
0845: * @param length
0846: * @throws java.sql.SQLException
0847: * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, int)
0848: */
0849: public void updateCharacterStream(int columnIndex, Reader x,
0850: int length) throws SQLException {
0851: throw new UnsupportedFeatureException(
0852: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0853:
0854: }
0855:
0856: /**
0857: *
0858: * @param columnIndex
0859: * @param x
0860: * @param scale
0861: * @throws java.sql.SQLException
0862: * @see java.sql.ResultSet#updateObject(int, java.lang.Object, int)
0863: */
0864: public void updateObject(int columnIndex, Object x, int scale)
0865: throws SQLException {
0866: throw new UnsupportedFeatureException(
0867: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0868:
0869: }
0870:
0871: /**
0872: *
0873: * @param columnIndex
0874: * @param x
0875: * @throws java.sql.SQLException
0876: * @see java.sql.ResultSet#updateObject(int, java.lang.Object)
0877: */
0878: public void updateObject(int columnIndex, Object x)
0879: throws SQLException {
0880: throw new UnsupportedFeatureException(
0881: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0882:
0883: }
0884:
0885: /**
0886: *
0887: * @param columnName
0888: * @throws java.sql.SQLException
0889: * @see java.sql.ResultSet#updateNull(java.lang.String)
0890: */
0891: public void updateNull(String columnName) throws SQLException {
0892: throw new UnsupportedFeatureException(
0893: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0894:
0895: }
0896:
0897: /**
0898: *
0899: * @param columnName
0900: * @param x
0901: * @throws java.sql.SQLException
0902: * @see java.sql.ResultSet#updateBoolean(java.lang.String, boolean)
0903: */
0904: public void updateBoolean(String columnName, boolean x)
0905: throws SQLException {
0906: throw new UnsupportedFeatureException(
0907: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0908:
0909: }
0910:
0911: /**
0912: *
0913: * @param columnName
0914: * @param x
0915: * @throws java.sql.SQLException
0916: * @see java.sql.ResultSet#updateByte(java.lang.String, byte)
0917: */
0918: public void updateByte(String columnName, byte x)
0919: throws SQLException {
0920: throw new UnsupportedFeatureException(
0921: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0922:
0923: }
0924:
0925: /**
0926: * Updates a column. This driver is read only, calling this method will
0927: * always result in an exception.
0928: * @param columnName
0929: * @param x
0930: * @throws java.sql.SQLException
0931: * @see java.sql.ResultSet#updateShort(java.lang.String, short)
0932: */
0933: public void updateShort(String columnName, short x)
0934: throws SQLException {
0935: throw new UnsupportedFeatureException(
0936: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0937:
0938: }
0939:
0940: /**
0941: * Updates a column. This driver is read only, calling this method will
0942: * always result in an exception.
0943: * @param columnName
0944: * @param x
0945: * @throws java.sql.SQLException
0946: * @see java.sql.ResultSet#updateInt(java.lang.String, int)
0947: */
0948: public void updateInt(String columnName, int x) throws SQLException {
0949: throw new UnsupportedFeatureException(
0950: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0951:
0952: }
0953:
0954: /**
0955: * Updates a column. This driver is read only, calling this method will
0956: * always result in an exception.
0957: * @param columnName
0958: * @param x
0959: * @throws java.sql.SQLException
0960: * @see java.sql.ResultSet#updateLong(java.lang.String, long)
0961: */
0962: public void updateLong(String columnName, long x)
0963: throws SQLException {
0964: throw new UnsupportedFeatureException(
0965: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0966:
0967: }
0968:
0969: /**
0970: * Updates a column. This driver is read only, calling this method will
0971: * always result in an exception.
0972: * @param columnName
0973: * @param x
0974: * @throws java.sql.SQLException
0975: * @see java.sql.ResultSet#updateFloat(java.lang.String, float)
0976: */
0977: public void updateFloat(String columnName, float x)
0978: throws SQLException {
0979: throw new UnsupportedFeatureException(
0980: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0981:
0982: }
0983:
0984: /**
0985: * Updates a column. This driver is read only, calling this method will
0986: * always result in an exception.
0987: * @param columnName
0988: * @param x
0989: * @throws java.sql.SQLException
0990: * @see java.sql.ResultSet#updateDouble(java.lang.String, double)
0991: */
0992: public void updateDouble(String columnName, double x)
0993: throws SQLException {
0994: throw new UnsupportedFeatureException(
0995: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
0996:
0997: }
0998:
0999: /**
1000: * Updates a column. This driver is read only, calling this method will
1001: * always result in an exception.
1002: * @param columnName
1003: * @param x
1004: * @throws java.sql.SQLException
1005: * @see java.sql.ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal)
1006: */
1007: public void updateBigDecimal(String columnName, BigDecimal x)
1008: throws SQLException {
1009: throw new UnsupportedFeatureException(
1010: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1011:
1012: }
1013:
1014: /**
1015: * Updates a column. This driver is read only, calling this method will
1016: * always result in an exception.
1017: * @param columnName
1018: * @param x
1019: * @throws java.sql.SQLException
1020: * @see java.sql.ResultSet#updateString(java.lang.String, java.lang.String)
1021: */
1022: public void updateString(String columnName, String x)
1023: throws SQLException {
1024: throw new UnsupportedFeatureException(
1025: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1026:
1027: }
1028:
1029: /**
1030: * Updates a column. This driver is read only, calling this method will
1031: * always result in an exception.
1032: * @param columnName
1033: * @param x
1034: * @throws java.sql.SQLException
1035: * @see java.sql.ResultSet#updateBytes(java.lang.String, byte[])
1036: */
1037: public void updateBytes(String columnName, byte[] x)
1038: throws SQLException {
1039: throw new UnsupportedFeatureException(
1040: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1041:
1042: }
1043:
1044: /**
1045: * Updates a column. This driver is read only, calling this method will
1046: * always result in an exception.
1047: * @param columnName
1048: * @param x
1049: * @throws java.sql.SQLException
1050: * @see java.sql.ResultSet#updateDate(java.lang.String, java.sql.Date)
1051: */
1052: public void updateDate(String columnName, java.sql.Date x)
1053: throws SQLException {
1054: throw new UnsupportedFeatureException(
1055: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1056:
1057: }
1058:
1059: /**
1060: * Updates a column. This driver is read only, calling this method will
1061: * always result in an exception.
1062: * @param columnName
1063: * @param x
1064: * @throws java.sql.SQLException
1065: * @see java.sql.ResultSet#updateTime(java.lang.String, java.sql.Time)
1066: */
1067: public void updateTime(String columnName, Time x)
1068: throws SQLException {
1069: throw new UnsupportedFeatureException(
1070: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1071:
1072: }
1073:
1074: /**
1075: * Updates a column. This driver is read only, calling this method will
1076: * always result in an exception.
1077: * @param columnName
1078: * @param x
1079: * @throws java.sql.SQLException
1080: * @see java.sql.ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp)
1081: */
1082: public void updateTimestamp(String columnName, Timestamp x)
1083: throws SQLException {
1084: throw new UnsupportedFeatureException(
1085: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1086:
1087: }
1088:
1089: /**
1090: * Updates a column. This driver is read only, calling this method will
1091: * always result in an exception.
1092: * @param columnName
1093: * @param x
1094: * @param length
1095: * @throws java.sql.SQLException
1096: * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, int)
1097: */
1098: public void updateAsciiStream(String columnName, InputStream x,
1099: int length) throws SQLException {
1100: throw new UnsupportedFeatureException(
1101: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1102:
1103: }
1104:
1105: /**
1106: * Updates a column. This driver is read only, calling this method will
1107: * always result in an exception.
1108: * @param columnName
1109: * @param x
1110: * @param length
1111: * @throws java.sql.SQLException
1112: * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, int)
1113: */
1114: public void updateBinaryStream(String columnName, InputStream x,
1115: int length) throws SQLException {
1116: throw new UnsupportedFeatureException(
1117: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1118: }
1119:
1120: /**
1121: * Updates a column. This driver is read only, calling this method will
1122: * always result in an exception.
1123: * @param columnName
1124: * @param reader
1125: * @param length
1126: * @throws java.sql.SQLException
1127: * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, int)
1128: */
1129: public void updateCharacterStream(String columnName, Reader reader,
1130: int length) throws SQLException {
1131: throw new UnsupportedFeatureException(
1132: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1133:
1134: }
1135:
1136: /**
1137: * Updates a column. This driver is read only, calling this method will
1138: * always result in an exception.
1139: * @param columnName
1140: * @param x
1141: * @param scale
1142: * @throws java.sql.SQLException
1143: * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object, int)
1144: */
1145: public void updateObject(String columnName, Object x, int scale)
1146: throws SQLException {
1147: throw new UnsupportedFeatureException(
1148: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1149:
1150: }
1151:
1152: /**
1153: * Updates a column. This driver is read only, calling this method will
1154: * always result in an exception.
1155: * @param columnName
1156: * @param x
1157: * @throws java.sql.SQLException
1158: * @see java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object)
1159: */
1160: public void updateObject(String columnName, Object x)
1161: throws SQLException {
1162: throw new UnsupportedFeatureException(
1163: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1164:
1165: }
1166:
1167: /**
1168: * Insert a row. This driver is read only, calling this method will
1169: * always result in an exception.
1170: * @throws java.sql.SQLException
1171: * @see java.sql.ResultSet#insertRow()
1172: */
1173: public void insertRow() throws SQLException {
1174: throw new UnsupportedFeatureException(
1175: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1176:
1177: }
1178:
1179: /**
1180: * Update a row. This driver is read only, calling this method will
1181: * always result in an exception.
1182: * @throws java.sql.SQLException
1183: * @see java.sql.ResultSet#updateRow()
1184: */
1185: public void updateRow() throws SQLException {
1186: throw new UnsupportedFeatureException(
1187: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1188:
1189: }
1190:
1191: /**
1192: * Delete a row. This driver is read only, calling this method will
1193: * always result in an exception.
1194: * @throws java.sql.SQLException
1195: * @see java.sql.ResultSet#deleteRow()
1196: */
1197: public void deleteRow() throws SQLException {
1198: throw new UnsupportedFeatureException(
1199: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1200:
1201: }
1202:
1203: /**
1204: * Refresh a row. This method is not supported, calling this method will
1205: * always result in an exception.
1206: * @throws java.sql.SQLException
1207: * @see java.sql.ResultSet#refreshRow()
1208: */
1209: public void refreshRow() throws SQLException {
1210: throw new UnsupportedFeatureException(
1211: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1212:
1213: }
1214:
1215: /**
1216: *
1217: * @throws java.sql.SQLException
1218: * @see java.sql.ResultSet#cancelRowUpdates()
1219: */
1220: public void cancelRowUpdates() throws SQLException {
1221: throw new UnsupportedFeatureException(
1222: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1223:
1224: }
1225:
1226: /**
1227: *
1228: * @throws java.sql.SQLException
1229: * @see java.sql.ResultSet#moveToInsertRow()
1230: */
1231: public void moveToInsertRow() throws SQLException {
1232: throw new UnsupportedFeatureException(
1233: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1234:
1235: }
1236:
1237: /**
1238: *
1239: * @throws java.sql.SQLException
1240: * @see java.sql.ResultSet#moveToCurrentRow()
1241: */
1242: public void moveToCurrentRow() throws SQLException {
1243: throw new UnsupportedFeatureException(
1244: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1245:
1246: }
1247:
1248: // Java 1.5
1249: /**
1250: * Get an object from the current result. Type mapping is not (yet) supported (will be ignored).
1251: * @param i
1252: * @param map
1253: * @return java.lang.Object
1254: * @throws java.sql.SQLException
1255: * @see java.sql.ResultSet#getObject(int, java.util.Map)
1256: */
1257: public Object getObject(int i, Map/*<String,Class<?>>*/map)
1258: throws SQLException {
1259: return getObject(i);
1260: }
1261:
1262: /**
1263: *
1264: * @param i
1265: * @return java.sql.Ref
1266: * @throws java.sql.SQLException
1267: * @see java.sql.ResultSet#getRef(int)
1268: */
1269: public Ref getRef(int i) throws SQLException {
1270: return (Ref) getObject(i);
1271:
1272: }
1273:
1274: /**
1275: *
1276: * @param i
1277: * @return java.sql.Blob
1278: * @throws java.sql.SQLException
1279: * @see java.sql.ResultSet#getBlob(int)
1280: */
1281: public Blob getBlob(int i) throws SQLException {
1282: return (Blob) getObject(i);
1283:
1284: }
1285:
1286: /**
1287: *
1288: * @param i
1289: * @return java.sql.Clob
1290: * @throws java.sql.SQLException
1291: * @see java.sql.ResultSet#getClob(int)
1292: */
1293: public Clob getClob(int i) throws SQLException {
1294: return (Clob) getObject(i);
1295:
1296: }
1297:
1298: /**
1299: *
1300: * @param i
1301: * @return java.sql.Array
1302: * @throws java.sql.SQLException
1303: * @see java.sql.ResultSet#getArray(int)
1304: */
1305: public Array getArray(int i) throws SQLException {
1306: return (Array) getObject(i);
1307:
1308: }
1309:
1310: // Java 1.5
1311: /**
1312: * Get an object from the current result. Type mapping is not (yet) supported (will be ignored).
1313: * @param colName
1314: * @param map
1315: * @return java.lang.Object
1316: * @throws java.sql.SQLException
1317: * @see java.sql.ResultSet#getObject(java.lang.String, java.util.Map)
1318: */
1319: public Object getObject(String colName,
1320: Map/*<String,Class<?>>*/map) throws SQLException {
1321: return getObject(colName);
1322: }
1323:
1324: /**
1325: *
1326: * @param colName
1327: * @return java.sql.Ref
1328: * @throws java.sql.SQLException
1329: * @see java.sql.ResultSet#getRef(java.lang.String)
1330: */
1331: public Ref getRef(String colName) throws SQLException {
1332: return (Ref) getObject(colName);
1333: }
1334:
1335: /**
1336: *
1337: * @param colName
1338: * @return java.sql.Blob
1339: * @throws java.sql.SQLException
1340: * @see java.sql.ResultSet#getBlob(java.lang.String)
1341: */
1342: public Blob getBlob(String colName) throws SQLException {
1343: return (Blob) getObject(colName);
1344:
1345: }
1346:
1347: /**
1348: *
1349: * @param colName
1350: * @return java.sql.Clob
1351: * @throws java.sql.SQLException
1352: * @see java.sql.ResultSet#getClob(java.lang.String)
1353: */
1354: public Clob getClob(String colName) throws SQLException {
1355: return (Clob) getObject(colName);
1356:
1357: }
1358:
1359: /**
1360: *
1361: * @param colName
1362: * @return java.sql.Array
1363: * @throws java.sql.SQLException
1364: * @see java.sql.ResultSet#getArray(java.lang.String)
1365: */
1366: public Array getArray(String colName) throws SQLException {
1367: return (Array) getObject(colName);
1368:
1369: }
1370:
1371: /**
1372: *
1373: * @param columnIndex
1374: * @param cal
1375: * @return java.sql.Date
1376: * @throws java.sql.SQLException
1377: * @see java.sql.ResultSet#getDate(int, java.util.Calendar)
1378: */
1379: public java.sql.Date getDate(int columnIndex, Calendar cal)
1380: throws SQLException {
1381: return (java.sql.Date) getObject(columnIndex);
1382: }
1383:
1384: /**
1385: *
1386: * @param columnName
1387: * @param cal
1388: * @return java.sql.Date
1389: * @throws java.sql.SQLException
1390: * @see java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar)
1391: */
1392: public java.sql.Date getDate(String columnName, Calendar cal)
1393: throws SQLException {
1394: return (java.sql.Date) getObject(columnName);
1395: }
1396:
1397: /**
1398: *
1399: * @param columnIndex
1400: * @param cal
1401: * @return java.sql.Time
1402: * @throws java.sql.SQLException
1403: * @see java.sql.ResultSet#getTime(int, java.util.Calendar)
1404: */
1405: public Time getTime(int columnIndex, Calendar cal)
1406: throws SQLException {
1407: return (Time) getObject(columnIndex);
1408:
1409: }
1410:
1411: /**
1412: *
1413: * @param columnName
1414: * @param cal
1415: * @return java.sql.Time
1416: * @throws java.sql.SQLException
1417: * @see java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar)
1418: */
1419: public Time getTime(String columnName, Calendar cal)
1420: throws SQLException {
1421: return (Time) getObject(columnName);
1422:
1423: }
1424:
1425: /**
1426: *
1427: * @param columnIndex
1428: * @param cal
1429: * @return java.sql.Timestamp
1430: * @throws java.sql.SQLException
1431: * @see java.sql.ResultSet#getTimestamp(int, java.util.Calendar)
1432: */
1433: public Timestamp getTimestamp(int columnIndex, Calendar cal)
1434: throws SQLException {
1435: return (Timestamp) getObject(columnIndex);
1436:
1437: }
1438:
1439: /**
1440: *
1441: * @param columnName
1442: * @param cal
1443: * @return java.sql.Timestamp
1444: * @throws java.sql.SQLException
1445: * @see java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar)
1446: */
1447: public Timestamp getTimestamp(String columnName, Calendar cal)
1448: throws SQLException {
1449: return (Timestamp) getObject(columnName);
1450:
1451: }
1452:
1453: /**
1454: *
1455: * @param columnIndex
1456: * @return java.net.URL
1457: * @throws java.sql.SQLException
1458: * @see java.sql.ResultSet#getURL(int)
1459: */
1460: public URL getURL(int columnIndex) throws SQLException {
1461: return (URL) getObject(columnIndex);
1462:
1463: }
1464:
1465: /**
1466: *
1467: * @param columnName
1468: * @return java.net.URL
1469: * @throws java.sql.SQLException
1470: * @see java.sql.ResultSet#getURL(java.lang.String)
1471: */
1472: public URL getURL(String columnName) throws SQLException {
1473: return (URL) getObject(columnName);
1474:
1475: }
1476:
1477: /**
1478: *
1479: * @param columnIndex
1480: * @param x
1481: * @throws java.sql.SQLException
1482: * @see java.sql.ResultSet#updateRef(int, java.sql.Ref)
1483: */
1484: public void updateRef(int columnIndex, Ref x) throws SQLException {
1485: throw new UnsupportedFeatureException(
1486: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1487:
1488: }
1489:
1490: /**
1491: *
1492: * @param columnName
1493: * @param x
1494: * @throws java.sql.SQLException
1495: * @see java.sql.ResultSet#updateRef(java.lang.String, java.sql.Ref)
1496: */
1497: public void updateRef(String columnName, Ref x) throws SQLException {
1498: throw new UnsupportedFeatureException(
1499: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1500:
1501: }
1502:
1503: /**
1504: *
1505: * @param columnIndex
1506: * @param x
1507: * @throws java.sql.SQLException
1508: * @see java.sql.ResultSet#updateBlob(int, java.sql.Blob)
1509: */
1510: public void updateBlob(int columnIndex, Blob x) throws SQLException {
1511: throw new UnsupportedFeatureException(
1512: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1513:
1514: }
1515:
1516: /**
1517: *
1518: * @param columnName
1519: * @param x
1520: * @throws java.sql.SQLException
1521: * @see java.sql.ResultSet#updateBlob(java.lang.String, java.sql.Blob)
1522: */
1523: public void updateBlob(String columnName, Blob x)
1524: throws SQLException {
1525: throw new UnsupportedFeatureException(
1526: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1527:
1528: }
1529:
1530: /**
1531: *
1532: * @param columnIndex
1533: * @param x
1534: * @throws java.sql.SQLException
1535: * @see java.sql.ResultSet#updateClob(int, java.sql.Clob)
1536: */
1537: public void updateClob(int columnIndex, Clob x) throws SQLException {
1538: throw new UnsupportedFeatureException(
1539: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1540:
1541: }
1542:
1543: /**
1544: *
1545: * @param columnName
1546: * @param x
1547: * @throws java.sql.SQLException
1548: * @see java.sql.ResultSet#updateClob(java.lang.String, java.sql.Clob)
1549: */
1550: public void updateClob(String columnName, Clob x)
1551: throws SQLException {
1552: throw new UnsupportedFeatureException(
1553: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1554:
1555: }
1556:
1557: /**
1558: *
1559: * @param columnIndex
1560: * @param x
1561: * @throws java.sql.SQLException
1562: * @see java.sql.ResultSet#updateArray(int, java.sql.Array)
1563: */
1564: public void updateArray(int columnIndex, Array x)
1565: throws SQLException {
1566: throw new UnsupportedFeatureException(
1567: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1568:
1569: }
1570:
1571: /**
1572: *
1573: * @param columnName
1574: * @param x
1575: * @throws java.sql.SQLException
1576: * @see java.sql.ResultSet#updateArray(java.lang.String, java.sql.Array)
1577: */
1578: public void updateArray(String columnName, Array x)
1579: throws SQLException {
1580: throw new UnsupportedFeatureException(
1581: "This feature is not supported by the mandarax jdbc driver - the driver is read only");
1582:
1583: }
1584:
1585: }
|