0001: /*
0002: * Copyright 2004-2008 H2 Group. Licensed under the H2 License, Version 1.0
0003: * (http://h2database.com/html/license.html).
0004: * Initial Developer: H2 Group
0005: */
0006: package org.h2.tools;
0007:
0008: import java.io.InputStream;
0009: import java.io.Reader;
0010: import java.math.BigDecimal;
0011: import java.net.URL;
0012: import java.sql.Array;
0013: import java.sql.Blob;
0014: import java.sql.Clob;
0015: import java.sql.Date;
0016: import java.sql.Ref;
0017: import java.sql.ResultSet;
0018: import java.sql.ResultSetMetaData;
0019: import java.sql.SQLException;
0020: import java.sql.SQLWarning;
0021: import java.sql.Statement;
0022: import java.sql.Time;
0023: import java.sql.Timestamp;
0024: import java.sql.Types;
0025: import java.util.ArrayList;
0026: import java.util.Calendar;
0027: import java.util.Map;
0028:
0029: //#ifdef JDK16
0030: /*
0031: import java.sql.NClob;
0032: import java.sql.RowId;
0033: import java.sql.SQLXML;
0034: */
0035: //#endif
0036: /**
0037: * This class is a simple result set and meta data implementation.
0038: * It can be used in Java functions that return a result set.
0039: * Only the most basic methods are implemented, the others throw an exception.
0040: * This implementation is standalone, and only relies on standard classes.
0041: * It can be extended easily if required.
0042: *
0043: * An application can create a result set using the following code:
0044: *
0045: * <pre>
0046: * SimpleResultSet rs = new SimpleResultSet();
0047: * rs.addColumn("ID", Types.INTEGER, 10, 0);
0048: * rs.addColumn("NAME", Types.VARCHAR, 255, 0);
0049: * rs.addRow(new Object[] { new Integer(0), "Hello" });
0050: * rs.addRow(new Object[] { new Integer(1), "World" });
0051: * </pre>
0052: *
0053: */
0054: public class SimpleResultSet implements ResultSet, ResultSetMetaData {
0055:
0056: private ArrayList rows;
0057: private Object[] currentRow;
0058: private int rowId = -1;
0059: private boolean wasNull;
0060: private SimpleRowSource source;
0061: private ArrayList columns = new ArrayList();
0062:
0063: private static class Column {
0064: String name;
0065: int sqlType;
0066: int precision;
0067: int scale;
0068: }
0069:
0070: /**
0071: * A simple array implementation,
0072: * backed by an object array
0073: */
0074: private static class SimpleArray implements Array {
0075:
0076: private Object[] value;
0077:
0078: private SimpleArray(Object[] value) {
0079: this .value = value;
0080: }
0081:
0082: /**
0083: * Get the object array.
0084: *
0085: * @return the object array
0086: */
0087: public Object getArray() throws SQLException {
0088: return value;
0089: }
0090:
0091: /**
0092: * INTERNAL
0093: */
0094: public Object getArray(Map map) throws SQLException {
0095: throw getUnsupportedException();
0096: }
0097:
0098: /**
0099: * INTERNAL
0100: */
0101: public Object getArray(long index, int count)
0102: throws SQLException {
0103: throw getUnsupportedException();
0104: }
0105:
0106: /**
0107: * INTERNAL
0108: */
0109: public Object getArray(long index, int count, Map map)
0110: throws SQLException {
0111: throw getUnsupportedException();
0112: }
0113:
0114: /**
0115: * Get the base type of this array.
0116: *
0117: * @return Types.NULL
0118: */
0119: public int getBaseType() throws SQLException {
0120: return Types.NULL;
0121: }
0122:
0123: /**
0124: * Get the base type name of this array.
0125: *
0126: * @return "NULL"
0127: */
0128: public String getBaseTypeName() throws SQLException {
0129: return "NULL";
0130: }
0131:
0132: /**
0133: * INTERNAL
0134: */
0135: public ResultSet getResultSet() throws SQLException {
0136: throw getUnsupportedException();
0137: }
0138:
0139: /**
0140: * INTERNAL
0141: */
0142: public ResultSet getResultSet(Map map) throws SQLException {
0143: throw getUnsupportedException();
0144: }
0145:
0146: /**
0147: * INTERNAL
0148: */
0149: public ResultSet getResultSet(long index, int count)
0150: throws SQLException {
0151: throw getUnsupportedException();
0152: }
0153:
0154: /**
0155: * INTERNAL
0156: */
0157: public ResultSet getResultSet(long index, int count, Map map)
0158: throws SQLException {
0159: throw getUnsupportedException();
0160: }
0161:
0162: /**
0163: * INTERNAL
0164: */
0165: public void free() throws SQLException {
0166: }
0167:
0168: }
0169:
0170: /**
0171: * This constructor is used if the result set is later populated with addRow.
0172: */
0173: public SimpleResultSet() {
0174: rows = new ArrayList();
0175: }
0176:
0177: /**
0178: * This constructor is used if the result set should retrieve the rows using
0179: * the specified row source object.
0180: *
0181: * @param source the row source
0182: */
0183: public SimpleResultSet(SimpleRowSource source) {
0184: this .source = source;
0185: }
0186:
0187: /**
0188: * Adds a column to the result set.
0189: *
0190: * @param name null is replaced with C1, C2,...
0191: * @param sqlType the value returned in getColumnType(..) (ignored internally)
0192: * @param precision the precision
0193: * @param scale the scale
0194: * @throws SQLException
0195: */
0196: public void addColumn(String name, int sqlType, int precision,
0197: int scale) throws SQLException {
0198: if (rows != null && rows.size() > 0) {
0199: throw new SQLException(
0200: "Cannot add a column after adding rows", "21S02");
0201: }
0202: if (name == null) {
0203: name = "C" + (columns.size() + 1);
0204: }
0205: Column column = new Column();
0206: column.name = name;
0207: column.sqlType = sqlType;
0208: column.precision = precision;
0209: column.scale = scale;
0210: columns.add(column);
0211: }
0212:
0213: /**
0214: * Add a new row to the result set.
0215: *
0216: * @param row the row as an array of objects
0217: */
0218: public void addRow(Object[] row) throws SQLException {
0219: if (rows == null) {
0220: throw new SQLException(
0221: "Cannot add a row when using RowSource", "21S02");
0222: }
0223: rows.add(row);
0224: }
0225:
0226: /**
0227: * Returns ResultSet.CONCUR_READ_ONLY.
0228: *
0229: * @return CONCUR_READ_ONLY
0230: */
0231: public int getConcurrency() throws SQLException {
0232: return ResultSet.CONCUR_READ_ONLY;
0233: }
0234:
0235: /**
0236: * Returns ResultSet.FETCH_FORWARD.
0237: *
0238: * @return FETCH_FORWARD
0239: */
0240: public int getFetchDirection() throws SQLException {
0241: return ResultSet.FETCH_FORWARD;
0242: }
0243:
0244: /**
0245: * Returns 0.
0246: *
0247: * @return 0
0248: */
0249: public int getFetchSize() throws SQLException {
0250: return 0;
0251: }
0252:
0253: /**
0254: * Returns the row number (1, 2,...) or 0 for no row.
0255: *
0256: * @return 0
0257: */
0258: public int getRow() throws SQLException {
0259: return rowId + 1;
0260: }
0261:
0262: /**
0263: * Returns ResultSet.TYPE_FORWARD_ONLY.
0264: *
0265: * @return TYPE_FORWARD_ONLY
0266: */
0267: public int getType() throws SQLException {
0268: return ResultSet.TYPE_FORWARD_ONLY;
0269: }
0270:
0271: /**
0272: * Closes the result set and releases the resources.
0273: */
0274: public void close() throws SQLException {
0275: currentRow = null;
0276: rows = null;
0277: columns = null;
0278: rowId = -1;
0279: if (source != null) {
0280: source.close();
0281: source = null;
0282: }
0283: }
0284:
0285: /**
0286: * Moves the cursor to the next row of the result set.
0287: *
0288: * @return true if successful, false if there are no more rows
0289: */
0290: public boolean next() throws SQLException {
0291: if (source != null) {
0292: rowId++;
0293: currentRow = source.readRow();
0294: if (currentRow != null) {
0295: return true;
0296: }
0297: } else if (rows != null && rowId < rows.size()) {
0298: rowId++;
0299: if (rowId < rows.size()) {
0300: currentRow = (Object[]) rows.get(rowId);
0301: return true;
0302: }
0303: }
0304: close();
0305: return false;
0306: }
0307:
0308: /**
0309: * Moves the current position to before the first row, that means resets the
0310: * result set.
0311: *
0312: * @throws SQLException is this method is not supported
0313: */
0314: public void beforeFirst() throws SQLException {
0315: rowId = -1;
0316: if (source != null) {
0317: source.reset();
0318: }
0319: }
0320:
0321: /**
0322: * Returns whether the last column accessed was null.
0323: *
0324: * @return true if the last column accessed was null
0325: */
0326: public boolean wasNull() throws SQLException {
0327: return wasNull;
0328: }
0329:
0330: /**
0331: * Returns the value as a byte.
0332: *
0333: * @return the value
0334: */
0335: public byte getByte(int columnIndex) throws SQLException {
0336: Object o = get(columnIndex);
0337: if (o != null && !(o instanceof Number)) {
0338: o = Byte.decode(o.toString());
0339: }
0340: return o == null ? 0 : ((Number) o).byteValue();
0341: }
0342:
0343: /**
0344: * Returns the value as an double.
0345: *
0346: * @return the value
0347: */
0348: public double getDouble(int columnIndex) throws SQLException {
0349: Object o = get(columnIndex);
0350: if (o != null && !(o instanceof Number)) {
0351: return Double.parseDouble(o.toString());
0352: }
0353: return o == null ? 0 : ((Number) o).doubleValue();
0354: }
0355:
0356: /**
0357: * Returns the value as a float.
0358: *
0359: * @return the value
0360: */
0361: public float getFloat(int columnIndex) throws SQLException {
0362: Object o = get(columnIndex);
0363: if (o != null && !(o instanceof Number)) {
0364: return Float.parseFloat(o.toString());
0365: }
0366: return o == null ? 0 : ((Number) o).floatValue();
0367: }
0368:
0369: /**
0370: * Returns the value as an int.
0371: *
0372: * @return the value
0373: */
0374: public int getInt(int columnIndex) throws SQLException {
0375: Object o = get(columnIndex);
0376: if (o != null && !(o instanceof Number)) {
0377: o = Integer.decode(o.toString());
0378: }
0379: return o == null ? 0 : ((Number) o).intValue();
0380: }
0381:
0382: /**
0383: * Returns the value as a long.
0384: *
0385: * @return the value
0386: */
0387: public long getLong(int columnIndex) throws SQLException {
0388: Object o = get(columnIndex);
0389: if (o != null && !(o instanceof Number)) {
0390: o = Long.decode(o.toString());
0391: }
0392: return o == null ? 0 : ((Number) o).longValue();
0393: }
0394:
0395: /**
0396: * Returns the value as a short.
0397: *
0398: * @return the value
0399: */
0400: public short getShort(int columnIndex) throws SQLException {
0401: Object o = get(columnIndex);
0402: if (o != null && !(o instanceof Number)) {
0403: o = Short.decode(o.toString());
0404: }
0405: return o == null ? 0 : ((Number) o).shortValue();
0406: }
0407:
0408: /**
0409: * Returns the value as a boolean.
0410: *
0411: * @return the value
0412: */
0413: public boolean getBoolean(int columnIndex) throws SQLException {
0414: Object o = get(columnIndex);
0415: if (o != null && !(o instanceof Boolean)) {
0416: o = Boolean.valueOf(o.toString());
0417: }
0418: return o == null ? false : ((Boolean) o).booleanValue();
0419: }
0420:
0421: /**
0422: * Returns the value as a byte array.
0423: *
0424: * @return the value
0425: */
0426: public byte[] getBytes(int columnIndex) throws SQLException {
0427: return (byte[]) get(columnIndex);
0428: }
0429:
0430: /**
0431: * Returns the value as an Object.
0432: *
0433: * @return the value
0434: */
0435: public Object getObject(int columnIndex) throws SQLException {
0436: return get(columnIndex);
0437: }
0438:
0439: /**
0440: * Returns the value as a String.
0441: *
0442: * @return the value
0443: */
0444: public String getString(int columnIndex) throws SQLException {
0445: Object o = get(columnIndex);
0446: return o == null ? null : o.toString();
0447: }
0448:
0449: /**
0450: * Returns the value as a byte.
0451: *
0452: * @return the value
0453: */
0454: public byte getByte(String columnName) throws SQLException {
0455: return getByte(findColumn(columnName));
0456: }
0457:
0458: /**
0459: * Returns the value as a double.
0460: *
0461: * @return the value
0462: */
0463: public double getDouble(String columnName) throws SQLException {
0464: return getDouble(findColumn(columnName));
0465: }
0466:
0467: /**
0468: * Returns the value as a float.
0469: *
0470: * @return the value
0471: */
0472: public float getFloat(String columnName) throws SQLException {
0473: return getFloat(findColumn(columnName));
0474: }
0475:
0476: /**
0477: * Searches for a specific column in the result set. A case-insensitive
0478: * search is made.
0479: *
0480: * @param columnName the name of the column label
0481: * @return the column index (1,2,...)
0482: * @throws SQLException if the column is not found or if the result set is
0483: * closed
0484: */
0485: public int findColumn(String columnName) throws SQLException {
0486: for (int i = 0; columnName != null && columns != null
0487: && i < columns.size(); i++) {
0488: if (columnName.equalsIgnoreCase(getColumn(i).name)) {
0489: return i + 1;
0490: }
0491: }
0492: throw new SQLException("Column not found: " + columnName,
0493: "42S22");
0494: }
0495:
0496: /**
0497: * Returns the value as an int.
0498: *
0499: * @return the value
0500: */
0501: public int getInt(String columnName) throws SQLException {
0502: return getInt(findColumn(columnName));
0503: }
0504:
0505: /**
0506: * Returns the value as a long.
0507: *
0508: * @return the value
0509: */
0510: public long getLong(String columnName) throws SQLException {
0511: return getLong(findColumn(columnName));
0512: }
0513:
0514: /**
0515: * Returns the value as a short.
0516: *
0517: * @return the value
0518: */
0519: public short getShort(String columnName) throws SQLException {
0520: return getShort(findColumn(columnName));
0521: }
0522:
0523: /**
0524: * Returns the value as a boolean.
0525: *
0526: * @return the value
0527: */
0528: public boolean getBoolean(String columnName) throws SQLException {
0529: return getBoolean(findColumn(columnName));
0530: }
0531:
0532: /**
0533: * Returns the value as a byte array.
0534: *
0535: * @return the value
0536: */
0537: public byte[] getBytes(String columnName) throws SQLException {
0538: return getBytes(findColumn(columnName));
0539: }
0540:
0541: /**
0542: * Returns the value as a java.math.BigDecimal.
0543: *
0544: * @return the value
0545: */
0546: public BigDecimal getBigDecimal(int columnIndex)
0547: throws SQLException {
0548: Object o = get(columnIndex);
0549: if (o != null && !(o instanceof BigDecimal)) {
0550: o = new BigDecimal(o.toString());
0551: }
0552: return (BigDecimal) o;
0553: }
0554:
0555: /**
0556: * Returns the value as an java.sql.Date.
0557: *
0558: * @return the value
0559: */
0560: public Date getDate(int columnIndex) throws SQLException {
0561: return (Date) get(columnIndex);
0562: }
0563:
0564: /**
0565: * Returns a reference to itself.
0566: *
0567: * @return this
0568: */
0569: public ResultSetMetaData getMetaData() throws SQLException {
0570: return this ;
0571: }
0572:
0573: /**
0574: * Returns null.
0575: *
0576: * @return null
0577: */
0578: public SQLWarning getWarnings() throws SQLException {
0579: return null;
0580: }
0581:
0582: /**
0583: * Returns null.
0584: *
0585: * @return null
0586: */
0587: public Statement getStatement() throws SQLException {
0588: return null;
0589: }
0590:
0591: /**
0592: * Returns the value as an java.sql.Time.
0593: *
0594: * @return the value
0595: */
0596: public Time getTime(int columnIndex) throws SQLException {
0597: return (Time) get(columnIndex);
0598: }
0599:
0600: /**
0601: * Returns the value as an java.sql.Timestamp.
0602: *
0603: * @return the value
0604: */
0605: public Timestamp getTimestamp(int columnIndex) throws SQLException {
0606: return (Timestamp) get(columnIndex);
0607: }
0608:
0609: /**
0610: * Returns the value as a java.sql.Array.
0611: *
0612: * @return the value
0613: */
0614: public Array getArray(int columnIndex) throws SQLException {
0615: return new SimpleArray((Object[]) get(columnIndex));
0616: }
0617:
0618: /**
0619: * Returns the value as an Object.
0620: *
0621: * @return the value
0622: */
0623: public Object getObject(String columnName) throws SQLException {
0624: return getObject(findColumn(columnName));
0625: }
0626:
0627: /**
0628: * Returns the value as a String.
0629: *
0630: * @return the value
0631: */
0632: public String getString(String columnName) throws SQLException {
0633: return getString(findColumn(columnName));
0634: }
0635:
0636: /**
0637: * Returns the value as a java.math.BigDecimal.
0638: *
0639: * @return the value
0640: */
0641: public BigDecimal getBigDecimal(String columnName)
0642: throws SQLException {
0643: return getBigDecimal(findColumn(columnName));
0644: }
0645:
0646: /**
0647: * Returns the value as a java.sql.Date.
0648: *
0649: * @return the value
0650: */
0651: public Date getDate(String columnName) throws SQLException {
0652: return getDate(findColumn(columnName));
0653: }
0654:
0655: /**
0656: * Returns the value as a java.sql.Time.
0657: *
0658: * @return the value
0659: */
0660: public Time getTime(String columnName) throws SQLException {
0661: return getTime(findColumn(columnName));
0662: }
0663:
0664: /**
0665: * Returns the value as a java.sql.Timestamp.
0666: *
0667: * @return the value
0668: */
0669: public Timestamp getTimestamp(String columnName)
0670: throws SQLException {
0671: return getTimestamp(findColumn(columnName));
0672: }
0673:
0674: /**
0675: * Returns the value as a java.sql.Array.
0676: *
0677: * @return the value
0678: */
0679: public Array getArray(String columnName) throws SQLException {
0680: return getArray(findColumn(columnName));
0681: }
0682:
0683: // ---- result set meta data ---------------------------------------------
0684:
0685: /**
0686: * Returns the column count.
0687: *
0688: * @return the column count
0689: */
0690: public int getColumnCount() throws SQLException {
0691: return columns.size();
0692: }
0693:
0694: /**
0695: * Returns 15.
0696: *
0697: * @return 15
0698: */
0699: public int getColumnDisplaySize(int columnIndex)
0700: throws SQLException {
0701: return 15;
0702: }
0703:
0704: /**
0705: * Returns the SQL type.
0706: *
0707: * @return the SQL type
0708: */
0709: public int getColumnType(int columnIndex) throws SQLException {
0710: return getColumn(columnIndex - 1).sqlType;
0711: }
0712:
0713: /**
0714: * Returns the precision.
0715: *
0716: * @return the precision
0717: */
0718: public int getPrecision(int columnIndex) throws SQLException {
0719: return getColumn(columnIndex - 1).precision;
0720: }
0721:
0722: /**
0723: * Returns the scale.
0724: *
0725: * @return the scale
0726: */
0727: public int getScale(int columnIndex) throws SQLException {
0728: return getColumn(columnIndex - 1).scale;
0729: }
0730:
0731: /**
0732: * Returns ResultSetMetaData.columnNullableUnknown.
0733: *
0734: * @return columnNullableUnknown
0735: */
0736: public int isNullable(int columnIndex) throws SQLException {
0737: return ResultSetMetaData.columnNullableUnknown;
0738: }
0739:
0740: /**
0741: * Returns false.
0742: *
0743: * @return false
0744: */
0745: public boolean isAutoIncrement(int columnIndex) throws SQLException {
0746: return false;
0747: }
0748:
0749: /**
0750: * Returns true.
0751: *
0752: * @return true
0753: */
0754: public boolean isCaseSensitive(int columnIndex) throws SQLException {
0755: return true;
0756: }
0757:
0758: /**
0759: * Returns false.
0760: *
0761: * @return false
0762: */
0763: public boolean isCurrency(int columnIndex) throws SQLException {
0764: return false;
0765: }
0766:
0767: /**
0768: * Returns false.
0769: *
0770: * @return false
0771: */
0772: public boolean isDefinitelyWritable(int columnIndex)
0773: throws SQLException {
0774: return false;
0775: }
0776:
0777: /**
0778: * Returns true.
0779: *
0780: * @return true
0781: */
0782: public boolean isReadOnly(int columnIndex) throws SQLException {
0783: return true;
0784: }
0785:
0786: /**
0787: * Returns true.
0788: *
0789: * @return true
0790: */
0791: public boolean isSearchable(int columnIndex) throws SQLException {
0792: return true;
0793: }
0794:
0795: /**
0796: * Returns true.
0797: *
0798: * @return true
0799: */
0800: public boolean isSigned(int columnIndex) throws SQLException {
0801: return true;
0802: }
0803:
0804: /**
0805: * Returns false.
0806: *
0807: * @return false
0808: */
0809: public boolean isWritable(int columnIndex) throws SQLException {
0810: return false;
0811: }
0812:
0813: /**
0814: * Returns null.
0815: *
0816: * @return null
0817: */
0818: public String getCatalogName(int columnIndex) throws SQLException {
0819: return null;
0820: }
0821:
0822: /**
0823: * Returns null.
0824: *
0825: * @return null
0826: */
0827: public String getColumnClassName(int columnIndex)
0828: throws SQLException {
0829: return null;
0830: }
0831:
0832: /**
0833: * Returns the column name.
0834: *
0835: * @return the column name
0836: */
0837: public String getColumnLabel(int columnIndex) throws SQLException {
0838: return getColumn(columnIndex - 1).name;
0839: }
0840:
0841: /**
0842: * Returns the column name.
0843: *
0844: * @return the column name
0845: */
0846: public String getColumnName(int columnIndex) throws SQLException {
0847: return getColumnLabel(columnIndex);
0848: }
0849:
0850: /**
0851: * Returns null.
0852: *
0853: * @return null
0854: */
0855: public String getColumnTypeName(int columnIndex)
0856: throws SQLException {
0857: return null;
0858: }
0859:
0860: /**
0861: * Returns null.
0862: *
0863: * @return null
0864: */
0865: public String getSchemaName(int columnIndex) throws SQLException {
0866: return null;
0867: }
0868:
0869: /**
0870: * Returns null.
0871: *
0872: * @return null
0873: */
0874: public String getTableName(int columnIndex) throws SQLException {
0875: return null;
0876: }
0877:
0878: // ---- unsupported / result set ---------------------------------------------
0879:
0880: /**
0881: * INTERNAL
0882: */
0883: public void clearWarnings() throws SQLException {
0884: }
0885:
0886: /**
0887: * INTERNAL
0888: */
0889: public void afterLast() throws SQLException {
0890: throw getUnsupportedException();
0891: }
0892:
0893: /**
0894: * INTERNAL
0895: */
0896: public void cancelRowUpdates() throws SQLException {
0897: throw getUnsupportedException();
0898: }
0899:
0900: /**
0901: * INTERNAL
0902: */
0903: public void updateNull(String columnName) throws SQLException {
0904: throw getUnsupportedException();
0905: }
0906:
0907: /**
0908: * INTERNAL
0909: */
0910: public void deleteRow() throws SQLException {
0911: throw getUnsupportedException();
0912: }
0913:
0914: /**
0915: * INTERNAL
0916: */
0917: public void insertRow() throws SQLException {
0918: throw getUnsupportedException();
0919: }
0920:
0921: /**
0922: * INTERNAL
0923: */
0924: public void moveToCurrentRow() throws SQLException {
0925: throw getUnsupportedException();
0926: }
0927:
0928: /**
0929: * INTERNAL
0930: */
0931: public void moveToInsertRow() throws SQLException {
0932: throw getUnsupportedException();
0933: }
0934:
0935: /**
0936: * INTERNAL
0937: */
0938: public void refreshRow() throws SQLException {
0939: throw getUnsupportedException();
0940: }
0941:
0942: /**
0943: * INTERNAL
0944: */
0945: public void updateRow() throws SQLException {
0946: throw getUnsupportedException();
0947: }
0948:
0949: /**
0950: * INTERNAL
0951: */
0952: public boolean first() throws SQLException {
0953: throw getUnsupportedException();
0954: }
0955:
0956: /**
0957: * INTERNAL
0958: */
0959: public boolean isAfterLast() throws SQLException {
0960: throw getUnsupportedException();
0961: }
0962:
0963: /**
0964: * INTERNAL
0965: */
0966: public boolean isBeforeFirst() throws SQLException {
0967: throw getUnsupportedException();
0968: }
0969:
0970: /**
0971: * INTERNAL
0972: */
0973: public boolean isFirst() throws SQLException {
0974: throw getUnsupportedException();
0975: }
0976:
0977: /**
0978: * INTERNAL
0979: */
0980: public boolean isLast() throws SQLException {
0981: throw getUnsupportedException();
0982: }
0983:
0984: /**
0985: * INTERNAL
0986: */
0987: public boolean last() throws SQLException {
0988: throw getUnsupportedException();
0989: }
0990:
0991: /**
0992: * INTERNAL
0993: */
0994: public boolean previous() throws SQLException {
0995: throw getUnsupportedException();
0996: }
0997:
0998: /**
0999: * INTERNAL
1000: */
1001: public boolean rowDeleted() throws SQLException {
1002: throw getUnsupportedException();
1003: }
1004:
1005: /**
1006: * INTERNAL
1007: */
1008: public boolean rowInserted() throws SQLException {
1009: throw getUnsupportedException();
1010: }
1011:
1012: /**
1013: * INTERNAL
1014: */
1015: public boolean rowUpdated() throws SQLException {
1016: throw getUnsupportedException();
1017: }
1018:
1019: /**
1020: * INTERNAL
1021: */
1022: public void setFetchDirection(int direction) throws SQLException {
1023: throw getUnsupportedException();
1024: }
1025:
1026: /**
1027: * INTERNAL
1028: */
1029: public void setFetchSize(int rows) throws SQLException {
1030: throw getUnsupportedException();
1031: }
1032:
1033: /**
1034: * INTERNAL
1035: */
1036: public void updateNull(int columnIndex) throws SQLException {
1037: throw getUnsupportedException();
1038: }
1039:
1040: /**
1041: * INTERNAL
1042: */
1043: public boolean absolute(int row) throws SQLException {
1044: throw getUnsupportedException();
1045: }
1046:
1047: /**
1048: * INTERNAL
1049: */
1050: public boolean relative(int rows) throws SQLException {
1051: throw getUnsupportedException();
1052: }
1053:
1054: /**
1055: * INTERNAL
1056: */
1057: public void updateByte(int columnIndex, byte x) throws SQLException {
1058: throw getUnsupportedException();
1059: }
1060:
1061: /**
1062: * INTERNAL
1063: */
1064: public void updateDouble(int columnIndex, double x)
1065: throws SQLException {
1066: throw getUnsupportedException();
1067: }
1068:
1069: /**
1070: * INTERNAL
1071: */
1072: public void updateFloat(int columnIndex, float x)
1073: throws SQLException {
1074: throw getUnsupportedException();
1075: }
1076:
1077: /**
1078: * INTERNAL
1079: */
1080: public void updateInt(int columnIndex, int x) throws SQLException {
1081: throw getUnsupportedException();
1082: }
1083:
1084: /**
1085: * INTERNAL
1086: */
1087: public void updateLong(int columnIndex, long x) throws SQLException {
1088: throw getUnsupportedException();
1089: }
1090:
1091: /**
1092: * INTERNAL
1093: */
1094: public void updateShort(int columnIndex, short x)
1095: throws SQLException {
1096: throw getUnsupportedException();
1097: }
1098:
1099: /**
1100: * INTERNAL
1101: */
1102: public void updateBoolean(int columnIndex, boolean x)
1103: throws SQLException {
1104: throw getUnsupportedException();
1105: }
1106:
1107: /**
1108: * INTERNAL
1109: */
1110: public void updateBytes(int columnIndex, byte[] x)
1111: throws SQLException {
1112: throw getUnsupportedException();
1113: }
1114:
1115: /**
1116: * INTERNAL
1117: */
1118: public InputStream getAsciiStream(int columnIndex)
1119: throws SQLException {
1120: return null;
1121: }
1122:
1123: /**
1124: * INTERNAL
1125: */
1126: public InputStream getBinaryStream(int columnIndex)
1127: throws SQLException {
1128: return null;
1129: }
1130:
1131: /**
1132: * @deprecated INTERNAL
1133: */
1134: public InputStream getUnicodeStream(int columnIndex)
1135: throws SQLException {
1136: return null;
1137: }
1138:
1139: /**
1140: * INTERNAL
1141: */
1142: public void updateAsciiStream(int columnIndex, InputStream x,
1143: int length) throws SQLException {
1144: throw getUnsupportedException();
1145: }
1146:
1147: /**
1148: * INTERNAL
1149: */
1150: public void updateBinaryStream(int columnIndex, InputStream x,
1151: int length) throws SQLException {
1152: throw getUnsupportedException();
1153: }
1154:
1155: /**
1156: * INTERNAL
1157: */
1158: public Reader getCharacterStream(int columnIndex)
1159: throws SQLException {
1160: throw getUnsupportedException();
1161: }
1162:
1163: /**
1164: * INTERNAL
1165: */
1166: public void updateCharacterStream(int columnIndex, Reader x,
1167: int length) throws SQLException {
1168: throw getUnsupportedException();
1169: }
1170:
1171: /**
1172: * INTERNAL
1173: */
1174: public void updateObject(int columnIndex, Object x)
1175: throws SQLException {
1176: throw getUnsupportedException();
1177: }
1178:
1179: /**
1180: * INTERNAL
1181: */
1182: public void updateObject(int columnIndex, Object x, int scale)
1183: throws SQLException {
1184: throw getUnsupportedException();
1185: }
1186:
1187: /**
1188: * INTERNAL
1189: */
1190: public String getCursorName() throws SQLException {
1191: throw getUnsupportedException();
1192: }
1193:
1194: /**
1195: * INTERNAL
1196: */
1197: public void updateString(int columnIndex, String x)
1198: throws SQLException {
1199: throw getUnsupportedException();
1200: }
1201:
1202: /**
1203: * INTERNAL
1204: */
1205: public void updateByte(String columnName, byte x)
1206: throws SQLException {
1207: throw getUnsupportedException();
1208: }
1209:
1210: /**
1211: * INTERNAL
1212: */
1213: public void updateDouble(String columnName, double x)
1214: throws SQLException {
1215: throw getUnsupportedException();
1216: }
1217:
1218: /**
1219: * INTERNAL
1220: */
1221: public void updateFloat(String columnName, float x)
1222: throws SQLException {
1223: throw getUnsupportedException();
1224: }
1225:
1226: /**
1227: * INTERNAL
1228: */
1229: public void updateInt(String columnName, int x) throws SQLException {
1230: throw getUnsupportedException();
1231: }
1232:
1233: /**
1234: * INTERNAL
1235: */
1236: public void updateLong(String columnName, long x)
1237: throws SQLException {
1238: throw getUnsupportedException();
1239: }
1240:
1241: /**
1242: * INTERNAL
1243: */
1244: public void updateShort(String columnName, short x)
1245: throws SQLException {
1246: throw getUnsupportedException();
1247: }
1248:
1249: /**
1250: * INTERNAL
1251: */
1252: public void updateBoolean(String columnName, boolean x)
1253: throws SQLException {
1254: throw getUnsupportedException();
1255: }
1256:
1257: /**
1258: * INTERNAL
1259: */
1260: public void updateBytes(String columnName, byte[] x)
1261: throws SQLException {
1262: throw getUnsupportedException();
1263: }
1264:
1265: /**
1266: * @deprecated INTERNAL
1267: */
1268: public BigDecimal getBigDecimal(int columnIndex, int scale)
1269: throws SQLException {
1270: throw getUnsupportedException();
1271: }
1272:
1273: /**
1274: * INTERNAL
1275: */
1276: public void updateBigDecimal(int columnIndex, BigDecimal x)
1277: throws SQLException {
1278: throw getUnsupportedException();
1279: }
1280:
1281: /**
1282: * INTERNAL
1283: */
1284: public URL getURL(int columnIndex) throws SQLException {
1285: throw getUnsupportedException();
1286: }
1287:
1288: /**
1289: * INTERNAL
1290: */
1291: public void updateArray(int columnIndex, Array x)
1292: throws SQLException {
1293: throw getUnsupportedException();
1294: }
1295:
1296: /**
1297: * INTERNAL
1298: */
1299: public Blob getBlob(int i) throws SQLException {
1300: throw getUnsupportedException();
1301: }
1302:
1303: /**
1304: * INTERNAL
1305: */
1306: public void updateBlob(int columnIndex, Blob x) throws SQLException {
1307: throw getUnsupportedException();
1308: }
1309:
1310: /**
1311: * INTERNAL
1312: */
1313: public Clob getClob(int i) throws SQLException {
1314: throw getUnsupportedException();
1315: }
1316:
1317: /**
1318: * INTERNAL
1319: */
1320: public void updateClob(int columnIndex, Clob x) throws SQLException {
1321: throw getUnsupportedException();
1322: }
1323:
1324: /**
1325: * INTERNAL
1326: */
1327: public void updateDate(int columnIndex, Date x) throws SQLException {
1328: throw getUnsupportedException();
1329: }
1330:
1331: /**
1332: * INTERNAL
1333: */
1334: public Ref getRef(int i) throws SQLException {
1335: throw getUnsupportedException();
1336: }
1337:
1338: /**
1339: * INTERNAL
1340: */
1341: public void updateRef(int columnIndex, Ref x) throws SQLException {
1342: throw getUnsupportedException();
1343: }
1344:
1345: /**
1346: * INTERNAL
1347: */
1348: public void updateTime(int columnIndex, Time x) throws SQLException {
1349: throw getUnsupportedException();
1350: }
1351:
1352: /**
1353: * INTERNAL
1354: */
1355: public void updateTimestamp(int columnIndex, Timestamp x)
1356: throws SQLException {
1357: throw getUnsupportedException();
1358: }
1359:
1360: /**
1361: * INTERNAL
1362: */
1363: public InputStream getAsciiStream(String columnName)
1364: throws SQLException {
1365: throw getUnsupportedException();
1366: }
1367:
1368: /**
1369: * INTERNAL
1370: */
1371: public InputStream getBinaryStream(String columnName)
1372: throws SQLException {
1373: throw getUnsupportedException();
1374: }
1375:
1376: /**
1377: * @deprecated INTERNAL
1378: */
1379: public InputStream getUnicodeStream(String columnName)
1380: throws SQLException {
1381: throw getUnsupportedException();
1382: }
1383:
1384: /**
1385: * INTERNAL
1386: */
1387: public void updateAsciiStream(String columnName, InputStream x,
1388: int length) throws SQLException {
1389: throw getUnsupportedException();
1390: }
1391:
1392: /**
1393: * INTERNAL
1394: */
1395: public void updateBinaryStream(String columnName, InputStream x,
1396: int length) throws SQLException {
1397: throw getUnsupportedException();
1398: }
1399:
1400: /**
1401: * INTERNAL
1402: */
1403: public Reader getCharacterStream(String columnName)
1404: throws SQLException {
1405: throw getUnsupportedException();
1406: }
1407:
1408: /**
1409: * INTERNAL
1410: */
1411: public void updateCharacterStream(String columnName, Reader reader,
1412: int length) throws SQLException {
1413: throw getUnsupportedException();
1414: }
1415:
1416: /**
1417: * INTERNAL
1418: */
1419: public void updateObject(String columnName, Object x)
1420: throws SQLException {
1421: throw getUnsupportedException();
1422: }
1423:
1424: /**
1425: * INTERNAL
1426: */
1427: public void updateObject(String columnName, Object x, int scale)
1428: throws SQLException {
1429: throw getUnsupportedException();
1430: }
1431:
1432: /**
1433: * INTERNAL
1434: */
1435: public Object getObject(int i, Map map) throws SQLException {
1436: throw getUnsupportedException();
1437: }
1438:
1439: /**
1440: * INTERNAL
1441: */
1442: public void updateString(String columnName, String x)
1443: throws SQLException {
1444: throw getUnsupportedException();
1445: }
1446:
1447: /**
1448: * @deprecated INTERNAL
1449: */
1450: public BigDecimal getBigDecimal(String columnName, int scale)
1451: throws SQLException {
1452: throw getUnsupportedException();
1453: }
1454:
1455: /**
1456: * INTERNAL
1457: */
1458: public void updateBigDecimal(String columnName, BigDecimal x)
1459: throws SQLException {
1460: throw getUnsupportedException();
1461: }
1462:
1463: /**
1464: * INTERNAL
1465: */
1466: public URL getURL(String columnName) throws SQLException {
1467: throw getUnsupportedException();
1468: }
1469:
1470: /**
1471: * INTERNAL
1472: */
1473: public void updateArray(String columnName, Array x)
1474: throws SQLException {
1475: throw getUnsupportedException();
1476: }
1477:
1478: /**
1479: * INTERNAL
1480: */
1481: public Blob getBlob(String colName) throws SQLException {
1482: throw getUnsupportedException();
1483: }
1484:
1485: /**
1486: * INTERNAL
1487: */
1488: public void updateBlob(String columnName, Blob x)
1489: throws SQLException {
1490: throw getUnsupportedException();
1491: }
1492:
1493: /**
1494: * INTERNAL
1495: */
1496: public Clob getClob(String colName) throws SQLException {
1497: throw getUnsupportedException();
1498: }
1499:
1500: /**
1501: * INTERNAL
1502: */
1503: public void updateClob(String columnName, Clob x)
1504: throws SQLException {
1505: throw getUnsupportedException();
1506: }
1507:
1508: /**
1509: * INTERNAL
1510: */
1511: public void updateDate(String columnName, Date x)
1512: throws SQLException {
1513: throw getUnsupportedException();
1514: }
1515:
1516: /**
1517: * INTERNAL
1518: */
1519: public Date getDate(int columnIndex, Calendar cal)
1520: throws SQLException {
1521: throw getUnsupportedException();
1522: }
1523:
1524: /**
1525: * INTERNAL
1526: */
1527: public Ref getRef(String colName) throws SQLException {
1528: throw getUnsupportedException();
1529: }
1530:
1531: /**
1532: * INTERNAL
1533: */
1534: public void updateRef(String columnName, Ref x) throws SQLException {
1535: throw getUnsupportedException();
1536: }
1537:
1538: /**
1539: * INTERNAL
1540: */
1541: public void updateTime(String columnName, Time x)
1542: throws SQLException {
1543: throw getUnsupportedException();
1544: }
1545:
1546: /**
1547: * INTERNAL
1548: */
1549: public Time getTime(int columnIndex, Calendar cal)
1550: throws SQLException {
1551: throw getUnsupportedException();
1552: }
1553:
1554: /**
1555: * INTERNAL
1556: */
1557: public void updateTimestamp(String columnName, Timestamp x)
1558: throws SQLException {
1559: throw getUnsupportedException();
1560: }
1561:
1562: /**
1563: * INTERNAL
1564: */
1565: public Timestamp getTimestamp(int columnIndex, Calendar cal)
1566: throws SQLException {
1567: throw getUnsupportedException();
1568: }
1569:
1570: /**
1571: * INTERNAL
1572: */
1573: public Object getObject(String colName, Map map)
1574: throws SQLException {
1575: throw getUnsupportedException();
1576: }
1577:
1578: /**
1579: * INTERNAL
1580: */
1581: public Date getDate(String columnName, Calendar cal)
1582: throws SQLException {
1583: throw getUnsupportedException();
1584: }
1585:
1586: /**
1587: * INTERNAL
1588: */
1589: public Time getTime(String columnName, Calendar cal)
1590: throws SQLException {
1591: throw getUnsupportedException();
1592: }
1593:
1594: /**
1595: * INTERNAL
1596: */
1597: public Timestamp getTimestamp(String columnName, Calendar cal)
1598: throws SQLException {
1599: throw getUnsupportedException();
1600: }
1601:
1602: // --- private -----------------------------
1603:
1604: private static SQLException getUnsupportedException() {
1605: return new SQLException("Feature not supported", "HYC00");
1606: }
1607:
1608: private void checkColumnIndex(int columnIndex) throws SQLException {
1609: if (columnIndex < 0 || columnIndex >= columns.size()) {
1610: throw new SQLException("Invalid column index "
1611: + (columnIndex + 1), "90009");
1612: }
1613: }
1614:
1615: private Object get(int columnIndex) throws SQLException {
1616: if (currentRow == null) {
1617: throw new SQLException("No data is available", "02000");
1618: }
1619: columnIndex--;
1620: checkColumnIndex(columnIndex);
1621: Object o = columnIndex < currentRow.length ? currentRow[columnIndex]
1622: : null;
1623: wasNull = o == null;
1624: return o;
1625: }
1626:
1627: private Column getColumn(int i) throws SQLException {
1628: checkColumnIndex(i);
1629: return (Column) columns.get(i);
1630: }
1631:
1632: /**
1633: * INTERNAL
1634: */
1635: //#ifdef JDK16
1636: /*
1637: public RowId getRowId(int columnIndex) throws SQLException {
1638: throw getUnsupportedException();
1639: }
1640: */
1641: //#endif
1642: /**
1643: * INTERNAL
1644: */
1645: //#ifdef JDK16
1646: /*
1647: public RowId getRowId(String columnName) throws SQLException {
1648: throw getUnsupportedException();
1649: }
1650: */
1651: //#endif
1652: /**
1653: * INTERNAL
1654: */
1655: //#ifdef JDK16
1656: /*
1657: public void updateRowId(int columnIndex, RowId x) throws SQLException {
1658: throw getUnsupportedException();
1659: }
1660: */
1661: //#endif
1662: /**
1663: * INTERNAL
1664: */
1665: //#ifdef JDK16
1666: /*
1667: public void updateRowId(String columnName, RowId x) throws SQLException {
1668: throw getUnsupportedException();
1669: }
1670: */
1671: //#endif
1672: /**
1673: * Returns the current result set holdability.
1674: *
1675: * @return the holdability
1676: */
1677: //#ifdef JDK14
1678: public int getHoldability() {
1679: return ResultSet.HOLD_CURSORS_OVER_COMMIT;
1680: }
1681:
1682: //#endif
1683:
1684: /**
1685: * Returns whether this result set has been closed.
1686: *
1687: * @return true if the result set was closed
1688: */
1689: public boolean isClosed() throws SQLException {
1690: return rows == null;
1691: }
1692:
1693: /**
1694: * INTERNAL
1695: */
1696: public void updateNString(int columnIndex, String nString)
1697: throws SQLException {
1698: throw getUnsupportedException();
1699: }
1700:
1701: /**
1702: * INTERNAL
1703: */
1704: public void updateNString(String columnName, String nString)
1705: throws SQLException {
1706: throw getUnsupportedException();
1707: }
1708:
1709: /**
1710: * INTERNAL
1711: */
1712: //#ifdef JDK16
1713: /*
1714: public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
1715: throw getUnsupportedException();
1716: }
1717: */
1718: //#endif
1719: /**
1720: * INTERNAL
1721: */
1722: //#ifdef JDK16
1723: /*
1724: public void updateNClob(String columnName, NClob nClob) throws SQLException {
1725: throw getUnsupportedException();
1726: }
1727: */
1728: //#endif
1729: /**
1730: * INTERNAL
1731: */
1732: //#ifdef JDK16
1733: /*
1734: public NClob getNClob(int columnIndex) throws SQLException {
1735: throw getUnsupportedException();
1736: }
1737: */
1738: //#endif
1739: /**
1740: * INTERNAL
1741: */
1742: //#ifdef JDK16
1743: /*
1744: public NClob getNClob(String columnName) throws SQLException {
1745: throw getUnsupportedException();
1746: }
1747: */
1748: //#endif
1749: /**
1750: * INTERNAL
1751: */
1752: //#ifdef JDK16
1753: /*
1754: public SQLXML getSQLXML(int columnIndex) throws SQLException {
1755: throw getUnsupportedException();
1756: }
1757: */
1758: //#endif
1759: /**
1760: * INTERNAL
1761: */
1762: //#ifdef JDK16
1763: /*
1764: public SQLXML getSQLXML(String columnName) throws SQLException {
1765: throw getUnsupportedException();
1766: }
1767: */
1768: //#endif
1769: /**
1770: * INTERNAL
1771: */
1772: //#ifdef JDK16
1773: /*
1774: public void updateSQLXML(int columnIndex, SQLXML xmlObject)
1775: throws SQLException {
1776: throw getUnsupportedException();
1777: }
1778: */
1779: //#endif
1780: /**
1781: * INTERNAL
1782: */
1783: //#ifdef JDK16
1784: /*
1785: public void updateSQLXML(String columnName, SQLXML xmlObject)
1786: throws SQLException {
1787: throw getUnsupportedException();
1788: }
1789: */
1790: //#endif
1791: /**
1792: * INTERNAL
1793: */
1794: public String getNString(int columnIndex) throws SQLException {
1795: return getString(columnIndex);
1796: }
1797:
1798: /**
1799: * INTERNAL
1800: */
1801: public String getNString(String columnName) throws SQLException {
1802: return getString(columnName);
1803: }
1804:
1805: /**
1806: * INTERNAL
1807: */
1808: public Reader getNCharacterStream(int columnIndex)
1809: throws SQLException {
1810: throw getUnsupportedException();
1811: }
1812:
1813: /**
1814: * INTERNAL
1815: */
1816: public Reader getNCharacterStream(String columnName)
1817: throws SQLException {
1818: throw getUnsupportedException();
1819: }
1820:
1821: /**
1822: * INTERNAL
1823: */
1824: public void updateNCharacterStream(int columnIndex, Reader x,
1825: int length) throws SQLException {
1826: throw getUnsupportedException();
1827: }
1828:
1829: /**
1830: * INTERNAL
1831: */
1832: public void updateNCharacterStream(String columnName, Reader x,
1833: int length) throws SQLException {
1834: throw getUnsupportedException();
1835: }
1836:
1837: /**
1838: * INTERNAL
1839: */
1840: //#ifdef JDK16
1841: /*
1842: public <T> T unwrap(Class<T> iface) throws SQLException {
1843: throw getUnsupportedException();
1844: }
1845: */
1846: //#endif
1847: /**
1848: * INTERNAL
1849: */
1850: //#ifdef JDK16
1851: /*
1852: public boolean isWrapperFor(Class<?> iface) throws SQLException {
1853: throw getUnsupportedException();
1854: }
1855: */
1856: //#endif
1857: /**
1858: * INTERNAL
1859: */
1860: public void updateAsciiStream(int columnIndex, InputStream x)
1861: throws SQLException {
1862: throw getUnsupportedException();
1863: }
1864:
1865: /**
1866: * INTERNAL
1867: */
1868: public void updateAsciiStream(String columnName, InputStream x)
1869: throws SQLException {
1870: throw getUnsupportedException();
1871: }
1872:
1873: /**
1874: * INTERNAL
1875: */
1876: public void updateAsciiStream(int columnIndex, InputStream x,
1877: long length) throws SQLException {
1878: throw getUnsupportedException();
1879: }
1880:
1881: /**
1882: * INTERNAL
1883: */
1884: public void updateAsciiStream(String columnName, InputStream x,
1885: long length) throws SQLException {
1886: throw getUnsupportedException();
1887: }
1888:
1889: /**
1890: * INTERNAL
1891: */
1892: public void updateBinaryStream(int columnName, InputStream x)
1893: throws SQLException {
1894: throw getUnsupportedException();
1895: }
1896:
1897: /**
1898: * INTERNAL
1899: */
1900: public void updateBinaryStream(String columnName, InputStream x)
1901: throws SQLException {
1902: throw getUnsupportedException();
1903: }
1904:
1905: /**
1906: * INTERNAL
1907: */
1908: public void updateBinaryStream(int columnIndex, InputStream x,
1909: long length) throws SQLException {
1910: throw getUnsupportedException();
1911: }
1912:
1913: /**
1914: * INTERNAL
1915: */
1916: public void updateBinaryStream(String columnName, InputStream x,
1917: long length) throws SQLException {
1918: throw getUnsupportedException();
1919: }
1920:
1921: /**
1922: * INTERNAL
1923: */
1924: public void updateBlob(int columnIndex, InputStream x)
1925: throws SQLException {
1926: throw getUnsupportedException();
1927: }
1928:
1929: /**
1930: * INTERNAL
1931: */
1932: public void updateBlob(String columnName, InputStream x)
1933: throws SQLException {
1934: throw getUnsupportedException();
1935: }
1936:
1937: /**
1938: * INTERNAL
1939: */
1940: public void updateBlob(int columnIndex, InputStream x, long length)
1941: throws SQLException {
1942: throw getUnsupportedException();
1943: }
1944:
1945: /**
1946: * INTERNAL
1947: */
1948: public void updateBlob(String columnName, InputStream x, long length)
1949: throws SQLException {
1950: throw getUnsupportedException();
1951: }
1952:
1953: /**
1954: * INTERNAL
1955: */
1956: public void updateCharacterStream(int columnIndex, Reader x)
1957: throws SQLException {
1958: throw getUnsupportedException();
1959: }
1960:
1961: /**
1962: * INTERNAL
1963: */
1964: public void updateCharacterStream(String columnName, Reader x)
1965: throws SQLException {
1966: throw getUnsupportedException();
1967: }
1968:
1969: /**
1970: * INTERNAL
1971: */
1972: public void updateCharacterStream(int columnIndex, Reader x,
1973: long length) throws SQLException {
1974: throw getUnsupportedException();
1975: }
1976:
1977: /**
1978: * INTERNAL
1979: */
1980: public void updateCharacterStream(String columnName, Reader x,
1981: long length) throws SQLException {
1982: throw getUnsupportedException();
1983: }
1984:
1985: /**
1986: * INTERNAL
1987: */
1988: public void updateClob(int columnIndex, Reader x)
1989: throws SQLException {
1990: throw getUnsupportedException();
1991: }
1992:
1993: /**
1994: * INTERNAL
1995: */
1996: public void updateClob(String columnName, Reader x)
1997: throws SQLException {
1998: throw getUnsupportedException();
1999: }
2000:
2001: /**
2002: * INTERNAL
2003: */
2004: public void updateClob(int columnIndex, Reader x, long length)
2005: throws SQLException {
2006: throw getUnsupportedException();
2007: }
2008:
2009: /**
2010: * INTERNAL
2011: */
2012: public void updateClob(String columnName, Reader x, long length)
2013: throws SQLException {
2014: throw getUnsupportedException();
2015: }
2016:
2017: /**
2018: * INTERNAL
2019: */
2020: public void updateNCharacterStream(int columnIndex, Reader x)
2021: throws SQLException {
2022: throw getUnsupportedException();
2023: }
2024:
2025: /**
2026: * INTERNAL
2027: */
2028: public void updateNCharacterStream(String columnName, Reader x)
2029: throws SQLException {
2030: throw getUnsupportedException();
2031: }
2032:
2033: /**
2034: * INTERNAL
2035: */
2036: public void updateNCharacterStream(int columnIndex, Reader x,
2037: long length) throws SQLException {
2038: throw getUnsupportedException();
2039: }
2040:
2041: /**
2042: * INTERNAL
2043: */
2044: public void updateNCharacterStream(String columnName, Reader x,
2045: long length) throws SQLException {
2046: throw getUnsupportedException();
2047: }
2048:
2049: /**
2050: * INTERNAL
2051: */
2052: public void updateNClob(int columnIndex, Reader x)
2053: throws SQLException {
2054: throw getUnsupportedException();
2055: }
2056:
2057: /**
2058: * INTERNAL
2059: */
2060: public void updateNClob(String columnName, Reader x)
2061: throws SQLException {
2062: throw getUnsupportedException();
2063: }
2064:
2065: /**
2066: * INTERNAL
2067: */
2068: public void updateNClob(int columnIndex, Reader x, long length)
2069: throws SQLException {
2070: throw getUnsupportedException();
2071: }
2072:
2073: /**
2074: * INTERNAL
2075: */
2076: public void updateNClob(String columnName, Reader x, long length)
2077: throws SQLException {
2078: throw getUnsupportedException();
2079: }
2080:
2081: }
|