0001: /*
0002:
0003: Derby - Class org.apache.derby.vti.VTITemplate
0004:
0005: Licensed to the Apache Software Foundation (ASF) under one or more
0006: contributor license agreements. See the NOTICE file distributed with
0007: this work for additional information regarding copyright ownership.
0008: The ASF licenses this file to You under the Apache License, Version 2.0
0009: (the "License"); you may not use this file except in compliance with
0010: the License. You may obtain a copy of the License at
0011:
0012: http://www.apache.org/licenses/LICENSE-2.0
0013:
0014: Unless required by applicable law or agreed to in writing, software
0015: distributed under the License is distributed on an "AS IS" BASIS,
0016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0017: See the License for the specific language governing permissions and
0018: limitations under the License.
0019:
0020: */
0021:
0022: package org.apache.derby.vti;
0023:
0024: import java.sql.Connection;
0025: import java.sql.Statement;
0026: import java.sql.ResultSet;
0027: import java.sql.ResultSetMetaData;
0028: import java.sql.SQLException;
0029: import java.sql.SQLWarning;
0030: import java.math.BigDecimal;
0031:
0032: import java.net.URL;
0033: import java.util.Calendar;
0034: import java.sql.Ref;
0035: import java.sql.Blob;
0036: import java.sql.Clob;
0037: import java.sql.Array;
0038:
0039: /**
0040: An abstract implementation of ResultSet (JDK1.1/JDBC 1.2) that is useful
0041: when writing a read-only VTI (virtual table interface) or for
0042: the ResultSet returned by executeQuery in read-write VTI classes.
0043:
0044: This class implements most of the methods of the JDBC 1.2 interface java.sql.ResultSet,
0045: each one throwing a SQLException with the name of the method.
0046: A concrete subclass can then just implement the methods not implemented here
0047: and override any methods it needs to implement for correct functionality.
0048: <P>
0049: The methods not implemented here are
0050: <UL>
0051: <LI>next()
0052: <LI>close()
0053: <LI>getMetaData()
0054: </UL>
0055: <P>
0056:
0057: For virtual tables the database engine only calls methods defined
0058: in the JDBC 1.2 definition of java.sql.ResultSet.
0059: <BR>
0060: Classes that implement a JDBC 2.0 conformant java.sql.ResultSet can be used
0061: as virtual tables.
0062: */
0063: public abstract class VTITemplate implements ResultSet {
0064:
0065: //
0066: // java.sql.ResultSet calls, passed through to our result set.
0067: //
0068:
0069: /**
0070: * @see java.sql.ResultSet
0071: *
0072: * @exception SQLException on unexpected JDBC error
0073: */
0074: public boolean wasNull() throws SQLException {
0075: throw new SQLException("wasNull");
0076: }
0077:
0078: /**
0079: * @see java.sql.ResultSet
0080: *
0081: * @exception SQLException on unexpected JDBC error
0082: */
0083: public String getString(int columnIndex) throws SQLException {
0084: throw new SQLException("getString");
0085: }
0086:
0087: /**
0088: * @see java.sql.ResultSet
0089: *
0090: * @exception SQLException on unexpected JDBC error
0091: */
0092: public boolean getBoolean(int columnIndex) throws SQLException {
0093: throw new SQLException("getBoolean");
0094: }
0095:
0096: /**
0097: * @see java.sql.ResultSet
0098: *
0099: * @exception SQLException on unexpected JDBC error
0100: */
0101: public byte getByte(int columnIndex) throws SQLException {
0102: throw new SQLException("getByte");
0103: }
0104:
0105: /**
0106: * @see java.sql.ResultSet
0107: *
0108: * @exception SQLException on unexpected JDBC error
0109: */
0110: public short getShort(int columnIndex) throws SQLException {
0111: throw new SQLException("getShort");
0112: }
0113:
0114: /**
0115: * @see java.sql.ResultSet
0116: *
0117: * @exception SQLException on unexpected JDBC error
0118: */
0119: public int getInt(int columnIndex) throws SQLException {
0120: throw new SQLException("getInt");
0121: }
0122:
0123: /**
0124: * @see java.sql.ResultSet
0125: *
0126: * @exception SQLException on unexpected JDBC error
0127: */
0128: public long getLong(int columnIndex) throws SQLException {
0129: throw new SQLException("getLong");
0130: }
0131:
0132: /**
0133: * @see java.sql.ResultSet
0134: *
0135: * @exception SQLException on unexpected JDBC error
0136: */
0137: public float getFloat(int columnIndex) throws SQLException {
0138: throw new SQLException("getFloat");
0139: }
0140:
0141: /**
0142: * @see java.sql.ResultSet
0143: *
0144: * @exception SQLException on unexpected JDBC error
0145: */
0146: public double getDouble(int columnIndex) throws SQLException {
0147: throw new SQLException("getDouble");
0148: }
0149:
0150: /**
0151: * @see java.sql.ResultSet
0152: *
0153: * @exception SQLException on unexpected JDBC error
0154: */
0155: public BigDecimal getBigDecimal(int columnIndex, int scale)
0156: throws SQLException {
0157: throw new SQLException("getBigDecimal");
0158: }
0159:
0160: /**
0161: * @see java.sql.ResultSet
0162: *
0163: * @exception SQLException on unexpected JDBC error
0164: */
0165: public byte[] getBytes(int columnIndex) throws SQLException {
0166: throw new SQLException("getBytes");
0167: }
0168:
0169: /**
0170: * @see java.sql.ResultSet
0171: *
0172: * @exception SQLException on unexpected JDBC error
0173: */
0174: public java.sql.Date getDate(int columnIndex) throws SQLException {
0175: throw new SQLException("getDate");
0176: }
0177:
0178: /**
0179: * @see java.sql.ResultSet
0180: *
0181: * @exception SQLException on unexpected JDBC error
0182: */
0183: public java.sql.Time getTime(int columnIndex) throws SQLException {
0184: throw new SQLException("getTime");
0185: }
0186:
0187: /**
0188: * @see java.sql.ResultSet
0189: *
0190: * @exception SQLException on unexpected JDBC error
0191: */
0192: public java.sql.Timestamp getTimestamp(int columnIndex)
0193: throws SQLException {
0194: throw new SQLException("getTimestamp");
0195: }
0196:
0197: /**
0198: * @see java.sql.ResultSet
0199: *
0200: * @exception SQLException on unexpected JDBC error
0201: */
0202: public java.io.InputStream getAsciiStream(int columnIndex)
0203: throws SQLException {
0204: throw new SQLException("getAsciiStream");
0205: }
0206:
0207: /**
0208: * @see java.sql.ResultSet
0209: *
0210: * @exception SQLException on unexpected JDBC error
0211: */
0212: public java.io.InputStream getUnicodeStream(int columnIndex)
0213: throws SQLException {
0214: throw new SQLException("getUnicodeStream");
0215: }
0216:
0217: /**
0218: * @see java.sql.ResultSet
0219: *
0220: * @exception SQLException on unexpected JDBC error
0221: */
0222: public java.io.InputStream getBinaryStream(int columnIndex)
0223: throws SQLException {
0224: throw new SQLException("getBinaryStream");
0225: }
0226:
0227: /**
0228: * @see java.sql.ResultSet
0229: *
0230: * @exception SQLException on unexpected JDBC error
0231: */
0232: public String getString(String columnName) throws SQLException {
0233: return getString(findColumn(columnName));
0234: }
0235:
0236: /**
0237: * @see java.sql.ResultSet
0238: *
0239: * @exception SQLException on unexpected JDBC error
0240: */
0241: public boolean getBoolean(String columnName) throws SQLException {
0242: return getBoolean(findColumn(columnName));
0243: }
0244:
0245: /**
0246: * @see java.sql.ResultSet
0247: *
0248: * @exception SQLException on unexpected JDBC error
0249: */
0250: public byte getByte(String columnName) throws SQLException {
0251: return getByte(findColumn(columnName));
0252: }
0253:
0254: /**
0255: * @see java.sql.ResultSet
0256: *
0257: * @exception SQLException on unexpected JDBC error
0258: */
0259: public short getShort(String columnName) throws SQLException {
0260: return getShort(findColumn(columnName));
0261: }
0262:
0263: /**
0264: * @see java.sql.ResultSet
0265: *
0266: * @exception SQLException on unexpected JDBC error
0267: */
0268: public int getInt(String columnName) throws SQLException {
0269: return getInt(findColumn(columnName));
0270: }
0271:
0272: /**
0273: * @see java.sql.ResultSet
0274: *
0275: * @exception SQLException on unexpected JDBC error
0276: */
0277: public long getLong(String columnName) throws SQLException {
0278: return getLong(findColumn(columnName));
0279: }
0280:
0281: /**
0282: * @see java.sql.ResultSet
0283: *
0284: * @exception SQLException on unexpected JDBC error
0285: */
0286: public float getFloat(String columnName) throws SQLException {
0287: return getFloat(findColumn(columnName));
0288: }
0289:
0290: /**
0291: * @see java.sql.ResultSet
0292: *
0293: * @exception SQLException on unexpected JDBC error
0294: */
0295: public double getDouble(String columnName) throws SQLException {
0296: return getDouble(findColumn(columnName));
0297: }
0298:
0299: /**
0300: * @see java.sql.ResultSet
0301: *
0302: * @exception SQLException on unexpected JDBC error
0303: */
0304: public BigDecimal getBigDecimal(String columnName, int scale)
0305: throws SQLException {
0306: return getBigDecimal(findColumn(columnName), scale);
0307: }
0308:
0309: /**
0310: * @see java.sql.ResultSet
0311: *
0312: * @exception SQLException on unexpected JDBC error
0313: */
0314: public byte[] getBytes(String columnName) throws SQLException {
0315: return getBytes(findColumn(columnName));
0316: }
0317:
0318: /**
0319: * @see java.sql.ResultSet
0320: *
0321: * @exception SQLException on unexpected JDBC error
0322: */
0323: public java.sql.Date getDate(String columnName) throws SQLException {
0324: return getDate(findColumn(columnName));
0325: }
0326:
0327: /**
0328: * @see java.sql.ResultSet
0329: *
0330: * @exception SQLException on unexpected JDBC error
0331: */
0332: public java.sql.Time getTime(String columnName) throws SQLException {
0333: return getTime(findColumn(columnName));
0334: }
0335:
0336: /**
0337: * @see java.sql.ResultSet
0338: *
0339: * @exception SQLException on unexpected JDBC error
0340: */
0341: public java.sql.Timestamp getTimestamp(String columnName)
0342: throws SQLException {
0343: return getTimestamp(findColumn(columnName));
0344: }
0345:
0346: /**
0347: * @see java.sql.ResultSet
0348: *
0349: * @exception SQLException on unexpected JDBC error
0350: */
0351: public java.io.InputStream getAsciiStream(String columnName)
0352: throws SQLException {
0353: throw new SQLException("getAsciiStream");
0354: }
0355:
0356: /**
0357: * @see java.sql.ResultSet
0358: *
0359: * @exception SQLException on unexpected JDBC error
0360: */
0361: public java.io.InputStream getUnicodeStream(String columnName)
0362: throws SQLException {
0363: throw new SQLException("getUnicodeStream");
0364: }
0365:
0366: /**
0367: * @see java.sql.ResultSet
0368: *
0369: * @exception SQLException on unexpected JDBC error
0370: */
0371: public java.io.InputStream getBinaryStream(String columnName)
0372: throws SQLException {
0373: throw new SQLException("getBinaryStream");
0374: }
0375:
0376: /**
0377: * @exception SQLException if there is an error
0378: */
0379: public SQLWarning getWarnings() throws SQLException {
0380: return null;
0381: }
0382:
0383: /**
0384: * @exception SQLException if there is an error
0385: */
0386: public void clearWarnings() throws SQLException {
0387: }
0388:
0389: /**
0390: * @see java.sql.ResultSet
0391: *
0392: * @exception SQLException on unexpected JDBC error
0393: */
0394: public String getCursorName() throws SQLException {
0395: throw new SQLException("getCursorName");
0396: }
0397:
0398: /**
0399: * @see java.sql.ResultSet
0400: *
0401: * @exception SQLException on unexpected JDBC error
0402: */
0403: public Object getObject(int columnIndex) throws SQLException {
0404: throw new SQLException("getObject");
0405: }
0406:
0407: /**
0408: * @see java.sql.ResultSet
0409: *
0410: * @exception SQLException on unexpected JDBC error
0411: */
0412: public Object getObject(String columnName) throws SQLException {
0413: return getObject(findColumn(columnName));
0414: }
0415:
0416: /**
0417: * @see java.sql.ResultSet
0418: *
0419: * @exception SQLException on unexpected JDBC error
0420: */
0421: public int findColumn(String columnName) throws SQLException {
0422: throw new SQLException("findColumn");
0423: }
0424:
0425: /*
0426: ** JDBC 2.0 methods
0427: */
0428:
0429: /**
0430: * @see java.sql.ResultSet
0431: *
0432: * @exception SQLException on unexpected JDBC error
0433: */
0434: public java.io.Reader getCharacterStream(int columnIndex)
0435: throws SQLException {
0436: throw new SQLException("getCharacterStream");
0437: }
0438:
0439: /**
0440: * @see java.sql.ResultSet
0441: *
0442: * @exception SQLException on unexpected JDBC error
0443: */
0444: public java.io.Reader getCharacterStream(String columnName)
0445: throws SQLException {
0446: throw new SQLException("getCharacterStream");
0447: }
0448:
0449: /**
0450: * @see java.sql.ResultSet
0451: *
0452: * @exception SQLException on unexpected JDBC error
0453: */
0454: public BigDecimal getBigDecimal(int columnIndex)
0455: throws SQLException {
0456: throw new SQLException("getBigDecimal");
0457: }
0458:
0459: /**
0460: * @see java.sql.ResultSet
0461: *
0462: * @exception SQLException on unexpected JDBC error
0463: */
0464: public BigDecimal getBigDecimal(String columnName)
0465: throws SQLException {
0466: return getBigDecimal(findColumn(columnName));
0467: }
0468:
0469: /**
0470: * @see java.sql.ResultSet
0471: *
0472: * @exception SQLException on unexpected JDBC error
0473: */
0474: public boolean isBeforeFirst() throws SQLException {
0475: throw new SQLException("isBeforeFirst");
0476: }
0477:
0478: /**
0479: * @see java.sql.ResultSet
0480: *
0481: * @exception SQLException on unexpected JDBC error
0482: */
0483: public boolean isAfterLast() throws SQLException {
0484: throw new SQLException("isAfterLast");
0485: }
0486:
0487: /**
0488: * @see java.sql.ResultSet
0489: *
0490: * @exception SQLException on unexpected JDBC error
0491: */
0492: public boolean isFirst() throws SQLException {
0493: throw new SQLException("isFirst");
0494: }
0495:
0496: /**
0497: * @see java.sql.ResultSet
0498: *
0499: * @exception SQLException on unexpected JDBC error
0500: */
0501: public boolean isLast() throws SQLException {
0502: throw new SQLException("isLast");
0503: }
0504:
0505: /**
0506: * @see java.sql.ResultSet
0507: *
0508: * @exception SQLException on unexpected JDBC error
0509: */
0510: public void beforeFirst() throws SQLException {
0511: throw new SQLException("beforeFirst");
0512: }
0513:
0514: /**
0515: * @see java.sql.ResultSet
0516: *
0517: * @exception SQLException on unexpected JDBC error
0518: */
0519: public void afterLast() throws SQLException {
0520: throw new SQLException("afterLast");
0521: }
0522:
0523: /**
0524: * @see java.sql.ResultSet
0525: *
0526: * @exception SQLException on unexpected JDBC error
0527: */
0528: public boolean first() throws SQLException {
0529: throw new SQLException("first");
0530: }
0531:
0532: /**
0533: * @see java.sql.ResultSet
0534: *
0535: * @exception SQLException on unexpected JDBC error
0536: */
0537: public boolean last() throws SQLException {
0538: throw new SQLException("last");
0539: }
0540:
0541: /**
0542: * @see java.sql.ResultSet
0543: *
0544: * @exception SQLException on unexpected JDBC error
0545: */
0546: public int getRow() throws SQLException {
0547: throw new SQLException("getRow");
0548: }
0549:
0550: /**
0551: * @see java.sql.ResultSet
0552: *
0553: * @exception SQLException on unexpected JDBC error
0554: */
0555: public boolean absolute(int row) throws SQLException {
0556: throw new SQLException("absolute");
0557: }
0558:
0559: /**
0560: * @see java.sql.ResultSet
0561: *
0562: * @exception SQLException on unexpected JDBC error
0563: */
0564: public boolean relative(int rows) throws SQLException {
0565: throw new SQLException("relative");
0566: }
0567:
0568: /**
0569: * @see java.sql.ResultSet
0570: *
0571: * @exception SQLException on unexpected JDBC error
0572: */
0573: public boolean previous() throws SQLException {
0574: throw new SQLException("previous");
0575: }
0576:
0577: /**
0578: * @see java.sql.ResultSet
0579: *
0580: * @exception SQLException on unexpected JDBC error
0581: */
0582: public void setFetchDirection(int direction) throws SQLException {
0583: throw new SQLException("setFetchDirection");
0584: }
0585:
0586: /**
0587: * @see java.sql.ResultSet
0588: *
0589: * @exception SQLException on unexpected JDBC error
0590: */
0591: public int getFetchDirection() throws SQLException {
0592: throw new SQLException("getFetchDirection");
0593: }
0594:
0595: /**
0596: * @see java.sql.ResultSet
0597: *
0598: * @exception SQLException on unexpected JDBC error
0599: */
0600: public void setFetchSize(int rows) throws SQLException {
0601: throw new SQLException("setFetchSize");
0602: }
0603:
0604: /**
0605: * @see java.sql.ResultSet
0606: *
0607: * @exception SQLException on unexpected JDBC error
0608: */
0609: public int getFetchSize() throws SQLException {
0610: throw new SQLException("getFetchSize");
0611: }
0612:
0613: /**
0614: * @see java.sql.ResultSet
0615: *
0616: * @exception SQLException on unexpected JDBC error
0617: */
0618: public int getType() throws SQLException {
0619: throw new SQLException("getType");
0620: }
0621:
0622: /**
0623: * @see java.sql.ResultSet
0624: *
0625: * @exception SQLException on unexpected JDBC error
0626: */
0627: public int getConcurrency() throws SQLException {
0628: throw new SQLException("getConcurrency");
0629: }
0630:
0631: /**
0632: * @see java.sql.ResultSet
0633: *
0634: * @exception SQLException on unexpected JDBC error
0635: */
0636: public boolean rowUpdated() throws SQLException {
0637: throw new SQLException("rowUpdated");
0638: }
0639:
0640: /**
0641: * @see java.sql.ResultSet
0642: *
0643: * @exception SQLException on unexpected JDBC error
0644: */
0645: public boolean rowInserted() throws SQLException {
0646: throw new SQLException("rowInserted");
0647: }
0648:
0649: /**
0650: * @see java.sql.ResultSet
0651: *
0652: * @exception SQLException on unexpected JDBC error
0653: */
0654: public boolean rowDeleted() throws SQLException {
0655: throw new SQLException("rowDeleted");
0656: }
0657:
0658: /**
0659: * @see java.sql.ResultSet
0660: *
0661: * @exception SQLException on unexpected JDBC error
0662: */
0663: public void updateNull(int columnIndex) throws SQLException {
0664: throw new SQLException("updateNull");
0665: }
0666:
0667: /**
0668: * @see java.sql.ResultSet
0669: *
0670: * @exception SQLException on unexpected JDBC error
0671: */
0672: public void updateBoolean(int columnIndex, boolean x)
0673: throws SQLException {
0674: throw new SQLException("updateBoolean");
0675: }
0676:
0677: /**
0678: * @see java.sql.ResultSet
0679: *
0680: * @exception SQLException on unexpected JDBC error
0681: */
0682: public void updateByte(int columnIndex, byte x) throws SQLException {
0683: throw new SQLException("updateByte");
0684: }
0685:
0686: /**
0687: * @see java.sql.ResultSet
0688: *
0689: * @exception SQLException on unexpected JDBC error
0690: */
0691: public void updateShort(int columnIndex, short x)
0692: throws SQLException {
0693: throw new SQLException("updateShort");
0694: }
0695:
0696: /**
0697: * @see java.sql.ResultSet
0698: *
0699: * @exception SQLException on unexpected JDBC error
0700: */
0701: public void updateInt(int columnIndex, int x) throws SQLException {
0702: throw new SQLException("updateInt");
0703: }
0704:
0705: /**
0706: * @see java.sql.ResultSet
0707: *
0708: * @exception SQLException on unexpected JDBC error
0709: */
0710: public void updateLong(int columnIndex, long x) throws SQLException {
0711: throw new SQLException("updateLong");
0712: }
0713:
0714: /**
0715: * @see java.sql.ResultSet
0716: *
0717: * @exception SQLException on unexpected JDBC error
0718: */
0719: public void updateFloat(int columnIndex, float x)
0720: throws SQLException {
0721: throw new SQLException("updateFloat");
0722: }
0723:
0724: /**
0725: * @see java.sql.ResultSet
0726: *
0727: * @exception SQLException on unexpected JDBC error
0728: */
0729: public void updateDouble(int columnIndex, double x)
0730: throws SQLException {
0731: throw new SQLException("updateDouble");
0732: }
0733:
0734: /**
0735: * @see java.sql.ResultSet
0736: *
0737: * @exception SQLException on unexpected JDBC error
0738: */
0739: public void updateBigDecimal(int columnIndex, BigDecimal x)
0740: throws SQLException {
0741: throw new SQLException("updateBigDecimal");
0742: }
0743:
0744: /**
0745: * @see java.sql.ResultSet
0746: *
0747: * @exception SQLException on unexpected JDBC error
0748: */
0749: public void updateString(int columnIndex, String x)
0750: throws SQLException {
0751: throw new SQLException("updateString");
0752: }
0753:
0754: /**
0755: * @see java.sql.ResultSet
0756: *
0757: * @exception SQLException on unexpected JDBC error
0758: */
0759: public void updateBytes(int columnIndex, byte[] x)
0760: throws SQLException {
0761: throw new SQLException("updateBytes");
0762: }
0763:
0764: /**
0765: * @see java.sql.ResultSet
0766: *
0767: * @exception SQLException on unexpected JDBC error
0768: */
0769: public void updateDate(int columnIndex, java.sql.Date x)
0770: throws SQLException {
0771: throw new SQLException("updateDate");
0772: }
0773:
0774: /**
0775: * @see java.sql.ResultSet
0776: *
0777: * @exception SQLException on unexpected JDBC error
0778: */
0779: public void updateTime(int columnIndex, java.sql.Time x)
0780: throws SQLException {
0781: throw new SQLException("updateTime");
0782: }
0783:
0784: /**
0785: * @see java.sql.ResultSet
0786: *
0787: * @exception SQLException on unexpected JDBC error
0788: */
0789: public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
0790: throws SQLException {
0791: throw new SQLException("updateTimestamp");
0792: }
0793:
0794: /**
0795: * @see java.sql.ResultSet
0796: *
0797: * @exception SQLException on unexpected JDBC error
0798: */
0799: public void updateAsciiStream(int columnIndex,
0800: java.io.InputStream x, int length) throws SQLException {
0801: throw new SQLException("updateAsciiStream");
0802: }
0803:
0804: /**
0805: * @see java.sql.ResultSet
0806: *
0807: * @exception SQLException on unexpected JDBC error
0808: */
0809: public void updateBinaryStream(int columnIndex,
0810: java.io.InputStream x, int length) throws SQLException {
0811: throw new SQLException("updateBinaryStream");
0812: }
0813:
0814: /**
0815: * @see java.sql.ResultSet
0816: *
0817: * @exception SQLException on unexpected JDBC error
0818: */
0819: public void updateCharacterStream(int columnIndex,
0820: java.io.Reader x, int length) throws SQLException {
0821: throw new SQLException("updateCharacterStream");
0822: }
0823:
0824: /**
0825: * @see java.sql.ResultSet
0826: *
0827: * @exception SQLException on unexpected JDBC error
0828: */
0829: public void updateObject(int columnIndex, Object x, int scale)
0830: throws SQLException {
0831: throw new SQLException("updateObject");
0832: }
0833:
0834: /**
0835: * @see java.sql.ResultSet
0836: *
0837: * @exception SQLException on unexpected JDBC error
0838: */
0839: public void updateObject(int columnIndex, Object x)
0840: throws SQLException {
0841: throw new SQLException("updateObject");
0842: }
0843:
0844: /**
0845: * @see java.sql.ResultSet
0846: *
0847: * @exception SQLException on unexpected JDBC error
0848: */
0849: public void updateNull(String columnName) throws SQLException {
0850: throw new SQLException("updateNull");
0851: }
0852:
0853: /**
0854: * @see java.sql.ResultSet
0855: *
0856: * @exception SQLException on unexpected JDBC error
0857: */
0858: public void updateBoolean(String columnName, boolean x)
0859: throws SQLException {
0860: throw new SQLException("updateBoolean");
0861: }
0862:
0863: /**
0864: * @see java.sql.ResultSet
0865: *
0866: * @exception SQLException on unexpected JDBC error
0867: */
0868: public void updateByte(String columnName, byte x)
0869: throws SQLException {
0870: throw new SQLException("updateByte");
0871: }
0872:
0873: /**
0874: * @see java.sql.ResultSet
0875: *
0876: * @exception SQLException on unexpected JDBC error
0877: */
0878: public void updateShort(String columnName, short x)
0879: throws SQLException {
0880: throw new SQLException("updateShort");
0881: }
0882:
0883: /**
0884: * @see java.sql.ResultSet
0885: *
0886: * @exception SQLException on unexpected JDBC error
0887: */
0888: public void updateInt(String columnName, int x) throws SQLException {
0889: throw new SQLException("updateInt");
0890: }
0891:
0892: /**
0893: * @see java.sql.ResultSet
0894: *
0895: * @exception SQLException on unexpected JDBC error
0896: */
0897: public void updateLong(String columnName, long x)
0898: throws SQLException {
0899: throw new SQLException("updateLong");
0900: }
0901:
0902: /**
0903: * @see java.sql.ResultSet
0904: *
0905: * @exception SQLException on unexpected JDBC error
0906: */
0907: public void updateFloat(String columnName, float x)
0908: throws SQLException {
0909: throw new SQLException("updateFloat");
0910: }
0911:
0912: /**
0913: * @see java.sql.ResultSet
0914: *
0915: * @exception SQLException on unexpected JDBC error
0916: */
0917: public void updateDouble(String columnName, double x)
0918: throws SQLException {
0919: throw new SQLException("updateDouble");
0920: }
0921:
0922: /**
0923: * @see java.sql.ResultSet
0924: *
0925: * @exception SQLException on unexpected JDBC error
0926: */
0927: public void updateBigDecimal(String columnName, BigDecimal x)
0928: throws SQLException {
0929: throw new SQLException("updateBigDecimal");
0930: }
0931:
0932: /**
0933: * @see java.sql.ResultSet
0934: *
0935: * @exception SQLException on unexpected JDBC error
0936: */
0937: public void updateString(String columnName, String x)
0938: throws SQLException {
0939: throw new SQLException("updateString");
0940: }
0941:
0942: /**
0943: * @see java.sql.ResultSet
0944: *
0945: * @exception SQLException on unexpected JDBC error
0946: */
0947: public void updateBytes(String columnName, byte[] x)
0948: throws SQLException {
0949: throw new SQLException("updateBytes");
0950: }
0951:
0952: /**
0953: * @see java.sql.ResultSet
0954: *
0955: * @exception SQLException on unexpected JDBC error
0956: */
0957: public void updateDate(String columnName, java.sql.Date x)
0958: throws SQLException {
0959: throw new SQLException("updateDate");
0960: }
0961:
0962: /**
0963: * @see java.sql.ResultSet
0964: *
0965: * @exception SQLException on unexpected JDBC error
0966: */
0967: public void updateTime(String columnName, java.sql.Time x)
0968: throws SQLException {
0969: throw new SQLException("updateTime");
0970: }
0971:
0972: /**
0973: * @see java.sql.ResultSet
0974: *
0975: * @exception SQLException on unexpected JDBC error
0976: */
0977: public void updateTimestamp(String columnName, java.sql.Timestamp x)
0978: throws SQLException {
0979: throw new SQLException("updateTimestamp");
0980: }
0981:
0982: /**
0983: * @see java.sql.ResultSet
0984: *
0985: * @exception SQLException on unexpected JDBC error
0986: */
0987: public void updateAsciiStream(String columnName,
0988: java.io.InputStream x, int length) throws SQLException {
0989: throw new SQLException("updateAsciiStream");
0990: }
0991:
0992: /**
0993: * @see java.sql.ResultSet
0994: *
0995: * @exception SQLException on unexpected JDBC error
0996: */
0997: public void updateBinaryStream(String columnName,
0998: java.io.InputStream x, int length) throws SQLException {
0999: throw new SQLException("updateBinaryStream");
1000: }
1001:
1002: /**
1003: * @see java.sql.ResultSet
1004: *
1005: * @exception SQLException on unexpected JDBC error
1006: */
1007: public void updateCharacterStream(String columnName,
1008: java.io.Reader x, int length) throws SQLException {
1009: throw new SQLException("updateCharacterStream");
1010: }
1011:
1012: /**
1013: * @see java.sql.ResultSet
1014: *
1015: * @exception SQLException on unexpected JDBC error
1016: */
1017: public void updateObject(String columnName, Object x, int scale)
1018: throws SQLException {
1019: throw new SQLException("updateObject");
1020: }
1021:
1022: /**
1023: * @see java.sql.ResultSet
1024: *
1025: * @exception SQLException on unexpected JDBC error
1026: */
1027: public void updateObject(String columnName, Object x)
1028: throws SQLException {
1029: throw new SQLException("updateObject");
1030: }
1031:
1032: /**
1033: * @see java.sql.ResultSet
1034: *
1035: * @exception SQLException on unexpected JDBC error
1036: */
1037: public void insertRow() throws SQLException {
1038: throw new SQLException("insertRow");
1039: }
1040:
1041: /**
1042: * @see java.sql.ResultSet
1043: *
1044: * @exception SQLException on unexpected JDBC error
1045: */
1046: public void updateRow() throws SQLException {
1047: throw new SQLException("updateRow");
1048: }
1049:
1050: /**
1051: * @see java.sql.ResultSet
1052: *
1053: * @exception SQLException on unexpected JDBC error
1054: */
1055: public void deleteRow() throws SQLException {
1056: throw new SQLException("deleteRow");
1057: }
1058:
1059: /**
1060: * @see java.sql.ResultSet
1061: *
1062: * @exception SQLException on unexpected JDBC error
1063: */
1064: public void refreshRow() throws SQLException {
1065: throw new SQLException("refreshRow");
1066: }
1067:
1068: /**
1069: * @see java.sql.ResultSet
1070: *
1071: * @exception SQLException on unexpected JDBC error
1072: */
1073: public void cancelRowUpdates() throws SQLException {
1074: throw new SQLException("cancelRowUpdates");
1075: }
1076:
1077: /**
1078: * @see java.sql.ResultSet
1079: *
1080: * @exception SQLException on unexpected JDBC error
1081: */
1082: public void moveToInsertRow() throws SQLException {
1083: throw new SQLException("moveToInsertRow");
1084: }
1085:
1086: /**
1087: * @see java.sql.ResultSet
1088: *
1089: * @exception SQLException on unexpected JDBC error
1090: */
1091: public void moveToCurrentRow() throws SQLException {
1092: throw new SQLException("moveToCurrentRow");
1093: }
1094:
1095: /**
1096: * @see java.sql.ResultSet
1097: *
1098: * @exception SQLException on unexpected JDBC error
1099: */
1100: public Statement getStatement() throws SQLException {
1101: throw new SQLException("getStatement");
1102: }
1103:
1104: /**
1105: * @see java.sql.ResultSet
1106: *
1107: * @exception SQLException on unexpected JDBC error
1108: */
1109: public java.sql.Date getDate(int columnIndex, Calendar cal)
1110: throws SQLException {
1111: throw new SQLException("getDate");
1112: }
1113:
1114: /**
1115: * @see java.sql.ResultSet
1116: *
1117: * @exception SQLException on unexpected JDBC error
1118: */
1119: public java.sql.Date getDate(String columnName, Calendar cal)
1120: throws SQLException {
1121: throw new SQLException("getDate");
1122: }
1123:
1124: /**
1125: * @see java.sql.ResultSet
1126: *
1127: * @exception SQLException on unexpected JDBC error
1128: */
1129: public java.sql.Time getTime(int columnIndex, Calendar cal)
1130: throws SQLException {
1131: throw new SQLException("getTime");
1132: }
1133:
1134: /**
1135: * @see java.sql.ResultSet
1136: *
1137: * @exception SQLException on unexpected JDBC error
1138: */
1139: public java.sql.Time getTime(String columnName, Calendar cal)
1140: throws SQLException {
1141: throw new SQLException("getTime");
1142: }
1143:
1144: /**
1145: * @see java.sql.ResultSet
1146: *
1147: * @exception SQLException on unexpected JDBC error
1148: */
1149: public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
1150: throws SQLException {
1151: throw new SQLException("getTimestamp");
1152: }
1153:
1154: /**
1155: * @see java.sql.ResultSet
1156: *
1157: * @exception SQLException on unexpected JDBC error
1158: */
1159: public java.sql.Timestamp getTimestamp(String columnName,
1160: Calendar cal) throws SQLException {
1161: throw new SQLException("getTimestamp");
1162: }
1163:
1164: /*
1165: ** JDBC 3.0 methods
1166: */
1167:
1168: /**
1169: * @see java.sql.ResultSet
1170: *
1171: * @exception SQLException on unexpected JDBC error
1172: */
1173: public URL getURL(int columnIndex) throws SQLException {
1174: throw new SQLException("getURL");
1175: }
1176:
1177: /**
1178: * @see java.sql.ResultSet
1179: *
1180: * @exception SQLException on unexpected JDBC error
1181: */
1182: public URL getURL(String columnName) throws SQLException {
1183: throw new SQLException("getURL");
1184: }
1185:
1186: /**
1187: * @see java.sql.ResultSet
1188: *
1189: * @exception SQLException on unexpected JDBC error
1190: */
1191: public Object getObject(int i, java.util.Map map)
1192: throws SQLException {
1193: throw new SQLException("getObject");
1194: }
1195:
1196: /**
1197: * @see java.sql.ResultSet
1198: *
1199: * @exception SQLException on unexpected JDBC error
1200: */
1201: public Ref getRef(int i) throws SQLException {
1202: throw new SQLException("getRef");
1203: }
1204:
1205: /**
1206: * @see java.sql.ResultSet
1207: *
1208: * @exception SQLException on unexpected JDBC error
1209: */
1210: public Blob getBlob(int i) throws SQLException {
1211: throw new SQLException("getBlob");
1212: }
1213:
1214: /**
1215: * @see java.sql.ResultSet
1216: *
1217: * @exception SQLException on unexpected JDBC error
1218: */
1219: public Clob getClob(int i) throws SQLException {
1220: throw new SQLException("getClob");
1221: }
1222:
1223: /**
1224: * @see java.sql.ResultSet
1225: *
1226: * @exception SQLException on unexpected JDBC error
1227: */
1228: public Array getArray(int i) throws SQLException {
1229: throw new SQLException("getArray");
1230: }
1231:
1232: /**
1233: * @see java.sql.ResultSet
1234: *
1235: * @exception SQLException on unexpected JDBC error
1236: */
1237: public Object getObject(String colName, java.util.Map map)
1238: throws SQLException {
1239: throw new SQLException("getObject");
1240: }
1241:
1242: /**
1243: * @see java.sql.ResultSet
1244: *
1245: * @exception SQLException on unexpected JDBC error
1246: */
1247: public Ref getRef(String colName) throws SQLException {
1248: throw new SQLException("getRef");
1249: }
1250:
1251: /**
1252: * @see java.sql.ResultSet
1253: *
1254: * @exception SQLException on unexpected JDBC error
1255: */
1256: public Blob getBlob(String colName) throws SQLException {
1257: throw new SQLException("getBlob");
1258: }
1259:
1260: /**
1261: * @see java.sql.ResultSet
1262: *
1263: * @exception SQLException on unexpected JDBC error
1264: */
1265: public Clob getClob(String colName) throws SQLException {
1266: throw new SQLException("getClob");
1267: }
1268:
1269: /**
1270: * @see java.sql.ResultSet
1271: *
1272: * @exception SQLException on unexpected JDBC error
1273: */
1274: public Array getArray(String colName) throws SQLException {
1275: throw new SQLException("getArray");
1276: }
1277:
1278: // JDBC 3.0 methods - not implemented
1279:
1280: /**
1281: * @see java.sql.ResultSet
1282: *
1283: * @exception SQLException on unexpected JDBC error
1284: */
1285: public void updateRef(int columnIndex, Ref x) throws SQLException {
1286: throw new SQLException("updateRef");
1287: }
1288:
1289: /**
1290: * @see java.sql.ResultSet
1291: *
1292: * @exception SQLException on unexpected JDBC error
1293: */
1294: public void updateRef(String columnName, Ref x) throws SQLException {
1295: throw new SQLException("updateRef");
1296: }
1297:
1298: /**
1299: * @see java.sql.ResultSet
1300: *
1301: * @exception SQLException on unexpected JDBC error
1302: */
1303: public void updateBlob(int columnIndex, Blob x) throws SQLException {
1304: throw new SQLException("updateBlob");
1305: }
1306:
1307: /**
1308: * @see java.sql.ResultSet
1309: *
1310: * @exception SQLException on unexpected JDBC error
1311: */
1312: public void updateBlob(String columnName, Blob x)
1313: throws SQLException {
1314: throw new SQLException("updateBlob");
1315: }
1316:
1317: /**
1318: * @see java.sql.ResultSet
1319: *
1320: * @exception SQLException on unexpected JDBC error
1321: */
1322: public void updateClob(int columnIndex, Clob x) throws SQLException {
1323: throw new SQLException("updateClob");
1324: }
1325:
1326: /**
1327: * @see java.sql.ResultSet
1328: *
1329: * @exception SQLException on unexpected JDBC error
1330: */
1331: public void updateClob(String columnName, Clob x)
1332: throws SQLException {
1333: throw new SQLException("updateClob");
1334: }
1335:
1336: /**
1337: * @see java.sql.ResultSet
1338: *
1339: * @exception SQLException on unexpected JDBC error
1340: */
1341: public void updateArray(int columnIndex, Array x)
1342: throws SQLException {
1343: throw new SQLException("updateArray");
1344: }
1345:
1346: /**
1347: * @see java.sql.ResultSet
1348: *
1349: * @exception SQLException on unexpected JDBC error
1350: */
1351: public void updateArray(String columnName, Array x)
1352: throws SQLException {
1353: throw new SQLException("updateArray");
1354: }
1355: }
|