1 /*
2 Copyright 2002-2007 MySQL AB, 2008 Sun Microsystems
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of version 2 of the GNU General Public License as
6 published by the Free Software Foundation.
7
8 There are special exceptions to the terms and conditions of the GPL
9 as it is applied to this software. View the full text of the
10 exception in file EXCEPTIONS-CONNECTOR-J in the directory of this
11 software distribution.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
22 */
23 package com.mysql.jdbc;
24
25 import java.sql.SQLException;
26 import java.sql.Types;
27
28 /**
29 * A ResultSetMetaData object can be used to find out about the types and
30 * properties of the columns in a ResultSet
31 *
32 * @author Mark Matthews
33 * @version $Id: ResultSetMetaData.java,v 1.1.2.1 2005/05/13 18:58:38 mmatthews
34 * Exp $
35 *
36 * @see java.sql.ResultSetMetaData
37 */
38 public class ResultSetMetaData implements java.sql.ResultSetMetaData {
39 private static int clampedGetLength(Field f) {
40 long fieldLength = f.getLength();
41
42 if (fieldLength > Integer.MAX_VALUE) {
43 fieldLength = Integer.MAX_VALUE;
44 }
45
46 return (int) fieldLength;
47 }
48
49 /**
50 * Checks if the SQL Type is a Decimal/Number Type
51 *
52 * @param type
53 * SQL Type
54 *
55 * @return ...
56 */
57 private static final boolean isDecimalType(int type) {
58 switch (type) {
59 case Types.BIT:
60 case Types.TINYINT:
61 case Types.SMALLINT:
62 case Types.INTEGER:
63 case Types.BIGINT:
64 case Types.FLOAT:
65 case Types.REAL:
66 case Types.DOUBLE:
67 case Types.NUMERIC:
68 case Types.DECIMAL:
69 return true;
70 }
71
72 return false;
73 }
74
75 Field[] fields;
76 boolean useOldAliasBehavior = false;
77
78 private ExceptionInterceptor exceptionInterceptor;
79
80 /**
81 * Initialise for a result with a tuple set and a field descriptor set
82 *
83 * @param fields
84 * the array of field descriptors
85 */
86 public ResultSetMetaData(Field[] fields, boolean useOldAliasBehavior, ExceptionInterceptor exceptionInterceptor) {
87 this.fields = fields;
88 this.useOldAliasBehavior = useOldAliasBehavior;
89 this.exceptionInterceptor = exceptionInterceptor;
90 }
91
92 /**
93 * What's a column's table's catalog name?
94 *
95 * @param column
96 * the first column is 1, the second is 2...
97 *
98 * @return catalog name, or "" if not applicable
99 *
100 * @throws SQLException
101 * if a database access error occurs
102 */
103 public String getCatalogName(int column) throws SQLException {
104 Field f = getField(column);
105
106 String database = f.getDatabaseName();
107
108 return (database == null) ? "" : database; //$NON-NLS-1$
109 }
110
111 /**
112 * What's the Java character encoding name for the given column?
113 *
114 * @param column
115 * the first column is 1, the second is 2, etc.
116 *
117 * @return the Java character encoding name for the given column, or null if
118 * no Java character encoding maps to the MySQL character set for
119 * the given column.
120 *
121 * @throws SQLException
122 * if an invalid column index is given.
123 */
124 public String getColumnCharacterEncoding(int column) throws SQLException {
125 String mysqlName = getColumnCharacterSet(column);
126
127 String javaName = null;
128
129 if (mysqlName != null) {
130 javaName = CharsetMapping.getJavaEncodingForMysqlEncoding(
131 mysqlName, null);
132 }
133
134 return javaName;
135 }
136
137 /**
138 * What's the MySQL character set name for the given column?
139 *
140 * @param column
141 * the first column is 1, the second is 2, etc.
142 *
143 * @return the MySQL character set name for the given column
144 *
145 * @throws SQLException
146 * if an invalid column index is given.
147 */
148 public String getColumnCharacterSet(int column) throws SQLException {
149 return getField(column).getCharacterSet();
150 }
151
152 // --------------------------JDBC 2.0-----------------------------------
153
154 /**
155 * JDBC 2.0
156 *
157 * <p>
158 * Return the fully qualified name of the Java class whose instances are
159 * manufactured if ResultSet.getObject() is called to retrieve a value from
160 * the column. ResultSet.getObject() may return a subClass of the class
161 * returned by this method.
162 * </p>
163 *
164 * @param column
165 * the column number to retrieve information for
166 *
167 * @return the fully qualified name of the Java class whose instances are
168 * manufactured if ResultSet.getObject() is called to retrieve a
169 * value from the column.
170 *
171 * @throws SQLException
172 * if an error occurs
173 */
174 public String getColumnClassName(int column) throws SQLException {
175 Field f = getField(column);
176
177 return getClassNameForJavaType(f.getSQLType(),
178 f.isUnsigned(),
179 f.getMysqlType(),
180 f.isBinary() || f.isBlob(),
181 f.isOpaqueBinary());
182 }
183
184 /**
185 * Whats the number of columns in the ResultSet?
186 *
187 * @return the number
188 *
189 * @throws SQLException
190 * if a database access error occurs
191 */
192 public int getColumnCount() throws SQLException {
193 return this.fields.length;
194 }
195
196 /**
197 * What is the column's normal maximum width in characters?
198 *
199 * @param column
200 * the first column is 1, the second is 2, etc.
201 *
202 * @return the maximum width
203 *
204 * @throws SQLException
205 * if a database access error occurs
206 */
207 public int getColumnDisplaySize(int column) throws SQLException {
208 Field f = getField(column);
209
210 int lengthInBytes = clampedGetLength(f);
211
212 return lengthInBytes / f.getMaxBytesPerCharacter();
213 }
214
215 /**
216 * What is the suggested column title for use in printouts and displays?
217 *
218 * @param column
219 * the first column is 1, the second is 2, etc.
220 *
221 * @return the column label
222 *
223 * @throws SQLException
224 * if a database access error occurs
225 */
226 public String getColumnLabel(int column) throws SQLException {
227 if (this.useOldAliasBehavior) {
228 return getColumnName(column);
229 }
230
231 return getField(column).getColumnLabel();
232 }
233
234 /**
235 * What's a column's name?
236 *
237 * @param column
238 * the first column is 1, the second is 2, etc.
239 *
240 * @return the column name
241 *
242 * @throws SQLException
243 * if a databvase access error occurs
244 */
245 public String getColumnName(int column) throws SQLException {
246 if (this.useOldAliasBehavior) {
247 return getField(column).getName();
248 }
249
250 String name = getField(column).getNameNoAliases();
251
252 if (name != null && name.length() == 0) {
253 return getField(column).getName();
254 }
255
256 return name;
257 }
258
259 /**
260 * What is a column's SQL Type? (java.sql.Type int)
261 *
262 * @param column
263 * the first column is 1, the second is 2, etc.
264 *
265 * @return the java.sql.Type value
266 *
267 * @throws SQLException
268 * if a database access error occurs
269 *
270 * @see java.sql.Types
271 */
272 public int getColumnType(int column) throws SQLException {
273 return getField(column).getSQLType();
274 }
275
276 /**
277 * Whats is the column's data source specific type name?
278 *
279 * @param column
280 * the first column is 1, the second is 2, etc.
281 *
282 * @return the type name
283 *
284 * @throws SQLException
285 * if a database access error occurs
286 */
287 public String getColumnTypeName(int column) throws java.sql.SQLException {
288 Field field = getField(column);
289
290 int mysqlType = field.getMysqlType();
291 int jdbcType = field.getSQLType();
292
293 switch (mysqlType) {
294 case MysqlDefs.FIELD_TYPE_BIT:
295 return "BIT";
296 case MysqlDefs.FIELD_TYPE_DECIMAL:
297 case MysqlDefs.FIELD_TYPE_NEW_DECIMAL:
298 return field.isUnsigned() ? "DECIMAL UNSIGNED" : "DECIMAL";
299
300 case MysqlDefs.FIELD_TYPE_TINY:
301 return field.isUnsigned() ? "TINYINT UNSIGNED" : "TINYINT";
302
303 case MysqlDefs.FIELD_TYPE_SHORT:
304 return field.isUnsigned() ? "SMALLINT UNSIGNED" : "SMALLINT";
305
306 case MysqlDefs.FIELD_TYPE_LONG:
307 return field.isUnsigned() ? "INT UNSIGNED" : "INT";
308
309 case MysqlDefs.FIELD_TYPE_FLOAT:
310 return field.isUnsigned() ? "FLOAT UNSIGNED" : "FLOAT";
311
312 case MysqlDefs.FIELD_TYPE_DOUBLE:
313 return field.isUnsigned() ? "DOUBLE UNSIGNED" : "DOUBLE";
314
315 case MysqlDefs.FIELD_TYPE_NULL:
316 return "NULL"; //$NON-NLS-1$
317
318 case MysqlDefs.FIELD_TYPE_TIMESTAMP:
319 return "TIMESTAMP"; //$NON-NLS-1$
320
321 case MysqlDefs.FIELD_TYPE_LONGLONG:
322 return field.isUnsigned() ? "BIGINT UNSIGNED" : "BIGINT";
323
324 case MysqlDefs.FIELD_TYPE_INT24:
325 return field.isUnsigned() ? "MEDIUMINT UNSIGNED" : "MEDIUMINT";
326
327 case MysqlDefs.FIELD_TYPE_DATE:
328 return "DATE"; //$NON-NLS-1$
329
330 case MysqlDefs.FIELD_TYPE_TIME:
331 return "TIME"; //$NON-NLS-1$
332
333 case MysqlDefs.FIELD_TYPE_DATETIME:
334 return "DATETIME"; //$NON-NLS-1$
335
336 case MysqlDefs.FIELD_TYPE_TINY_BLOB:
337 return "TINYBLOB"; //$NON-NLS-1$
338
339 case MysqlDefs.FIELD_TYPE_MEDIUM_BLOB:
340 return "MEDIUMBLOB"; //$NON-NLS-1$
341
342 case MysqlDefs.FIELD_TYPE_LONG_BLOB:
343 return "LONGBLOB"; //$NON-NLS-1$
344
345 case MysqlDefs.FIELD_TYPE_BLOB:
346 if (getField(column).isBinary()) {
347 return "BLOB";//$NON-NLS-1$
348 }
349
350 return "TEXT";//$NON-NLS-1$
351
352 case MysqlDefs.FIELD_TYPE_VARCHAR:
353 return "VARCHAR"; //$NON-NLS-1$
354
355 case MysqlDefs.FIELD_TYPE_VAR_STRING:
356 if (jdbcType == Types.VARBINARY) {
357 return "VARBINARY";
358 }
359
360 return "VARCHAR"; //$NON-NLS-1$
361
362 case MysqlDefs.FIELD_TYPE_STRING:
363 if (jdbcType == Types.BINARY) {
364 return "BINARY";
365 }
366
367 return "CHAR"; //$NON-NLS-1$
368
369 case MysqlDefs.FIELD_TYPE_ENUM:
370 return "ENUM"; //$NON-NLS-1$
371
372 case MysqlDefs.FIELD_TYPE_YEAR:
373 return "YEAR"; // $NON_NLS-1$
374
375 case MysqlDefs.FIELD_TYPE_SET:
376 return "SET"; //$NON-NLS-1$
377
378 case MysqlDefs.FIELD_TYPE_GEOMETRY:
379 return "GEOMETRY"; //$NON-NLS-1$
380
381 default:
382 return "UNKNOWN"; //$NON-NLS-1$
383 }
384 }
385
386 /**
387 * Returns the field instance for the given column index
388 *
389 * @param columnIndex
390 * the column number to retrieve a field instance for
391 *
392 * @return the field instance for the given column index
393 *
394 * @throws SQLException
395 * if an error occurs
396 */
397 protected Field getField(int columnIndex) throws SQLException {
398 if ((columnIndex < 1) || (columnIndex > this.fields.length)) {
399 throw SQLError.createSQLException(Messages.getString("ResultSetMetaData.46"), //$NON-NLS-1$
400 SQLError.SQL_STATE_INVALID_COLUMN_NUMBER, this.exceptionInterceptor);
401 }
402
403 return this.fields[columnIndex - 1];
404 }
405
406 /**
407 * What is a column's number of decimal digits.
408 *
409 * @param column
410 * the first column is 1, the second is 2...
411 *
412 * @return the precision
413 *
414 * @throws SQLException
415 * if a database access error occurs
416 */
417 public int getPrecision(int column) throws SQLException {
418 Field f = getField(column);
419
420 // if (f.getMysqlType() == MysqlDefs.FIELD_TYPE_NEW_DECIMAL) {
421 // return f.getLength();
422 // }
423
424 if (isDecimalType(f.getSQLType())) {
425 if (f.getDecimals() > 0) {
426 return clampedGetLength(f) - 1 + f.getPrecisionAdjustFactor();
427 }
428
429 return clampedGetLength(f) + f.getPrecisionAdjustFactor();
430 }
431
432 switch (f.getMysqlType()) {
433 case MysqlDefs.FIELD_TYPE_TINY_BLOB:
434 case MysqlDefs.FIELD_TYPE_BLOB:
435 case MysqlDefs.FIELD_TYPE_MEDIUM_BLOB:
436 case MysqlDefs.FIELD_TYPE_LONG_BLOB:
437 return clampedGetLength(f); // this may change in the future
438 // for now, the server only
439 // returns FIELD_TYPE_BLOB for _all_
440 // BLOB types, but varying lengths
441 // indicating the _maximum_ size
442 // for each BLOB type.
443 default:
444 return clampedGetLength(f) / f.getMaxBytesPerCharacter();
445
446 }
447 }
448
449 /**
450 * What is a column's number of digits to the right of the decimal point?
451 *
452 * @param column
453 * the first column is 1, the second is 2...
454 *
455 * @return the scale
456 *
457 * @throws SQLException
458 * if a database access error occurs
459 */
460 public int getScale(int column) throws SQLException {
461 Field f = getField(column);
462
463 if (isDecimalType(f.getSQLType())) {
464 return f.getDecimals();
465 }
466
467 return 0;
468 }
469
470 /**
471 * What is a column's table's schema? This relies on us knowing the table
472 * name. The JDBC specification allows us to return "" if this is not
473 * applicable.
474 *
475 * @param column
476 * the first column is 1, the second is 2...
477 *
478 * @return the Schema
479 *
480 * @throws SQLException
481 * if a database access error occurs
482 */
483 public String getSchemaName(int column) throws SQLException {
484 return ""; //$NON-NLS-1$
485 }
486
487 /**
488 * Whats a column's table's name?
489 *
490 * @param column
491 * the first column is 1, the second is 2...
492 *
493 * @return column name, or "" if not applicable
494 *
495 * @throws SQLException
496 * if a database access error occurs
497 */
498 public String getTableName(int column) throws SQLException {
499 if (this.useOldAliasBehavior) {
500 return getField(column).getTableName();
501 }
502
503 return getField(column).getTableNameNoAliases();
504 }
505
506 /**
507 * Is the column automatically numbered (and thus read-only)
508 *
509 * @param column
510 * the first column is 1, the second is 2...
511 *
512 * @return true if so
513 *
514 * @throws SQLException
515 * if a database access error occurs
516 */
517 public boolean isAutoIncrement(int column) throws SQLException {
518 Field f = getField(column);
519
520 return f.isAutoIncrement();
521 }
522
523 /**
524 * Does a column's case matter?
525 *
526 * @param column
527 * the first column is 1, the second is 2...
528 *
529 * @return true if so
530 *
531 * @throws java.sql.SQLException
532 * if a database access error occurs
533 */
534 public boolean isCaseSensitive(int column) throws java.sql.SQLException {
535 Field field = getField(column);
536
537 int sqlType = field.getSQLType();
538
539 switch (sqlType) {
540 case Types.BIT:
541 case Types.TINYINT:
542 case Types.SMALLINT:
543 case Types.INTEGER:
544 case Types.BIGINT:
545 case Types.FLOAT:
546 case Types.REAL:
547 case Types.DOUBLE:
548 case Types.DATE:
549 case Types.TIME:
550 case Types.TIMESTAMP:
551 return false;
552
553 case Types.CHAR:
554 case Types.VARCHAR:
555 case Types.LONGVARCHAR:
556
557 if (field.isBinary()) {
558 return true;
559 }
560
561 String collationName = field.getCollation();
562
563 return ((collationName != null) && !collationName.endsWith("_ci"));
564
565 default:
566 return true;
567 }
568 }
569
570 /**
571 * Is the column a cash value?
572 *
573 * @param column
574 * the first column is 1, the second is 2...
575 *
576 * @return true if its a cash column
577 *
578 * @throws SQLException
579 * if a database access error occurs
580 */
581 public boolean isCurrency(int column) throws SQLException {
582 return false;
583 }
584
585 /**
586 * Will a write on this column definately succeed?
587 *
588 * @param column
589 * the first column is 1, the second is 2, etc..
590 *
591 * @return true if so
592 *
593 * @throws SQLException
594 * if a database access error occurs
595 */
596 public boolean isDefinitelyWritable(int column) throws SQLException {
597 return isWritable(column);
598 }
599
600 /**
601 * Can you put a NULL in this column?
602 *
603 * @param column
604 * the first column is 1, the second is 2...
605 *
606 * @return one of the columnNullable values
607 *
608 * @throws SQLException
609 * if a database access error occurs
610 */
611 public int isNullable(int column) throws SQLException {
612 if (!getField(column).isNotNull()) {
613 return java.sql.ResultSetMetaData.columnNullable;
614 }
615
616 return java.sql.ResultSetMetaData.columnNoNulls;
617 }
618
619 /**
620 * Is the column definitely not writable?
621 *
622 * @param column
623 * the first column is 1, the second is 2, etc.
624 *
625 * @return true if so
626 *
627 * @throws SQLException
628 * if a database access error occurs
629 */
630 public boolean isReadOnly(int column) throws SQLException {
631 return getField(column).isReadOnly();
632 }
633
634 /**
635 * Can the column be used in a WHERE clause? Basically for this, I split the
636 * functions into two types: recognised types (which are always useable),
637 * and OTHER types (which may or may not be useable). The OTHER types, for
638 * now, I will assume they are useable. We should really query the catalog
639 * to see if they are useable.
640 *
641 * @param column
642 * the first column is 1, the second is 2...
643 *
644 * @return true if they can be used in a WHERE clause
645 *
646 * @throws SQLException
647 * if a database access error occurs
648 */
649 public boolean isSearchable(int column) throws SQLException {
650 return true;
651 }
652
653 /**
654 * Is the column a signed number?
655 *
656 * @param column
657 * the first column is 1, the second is 2...
658 *
659 * @return true if so
660 *
661 * @throws SQLException
662 * if a database access error occurs
663 */
664 public boolean isSigned(int column) throws SQLException {
665 Field f = getField(column);
666 int sqlType = f.getSQLType();
667
668 switch (sqlType) {
669 case Types.TINYINT:
670 case Types.SMALLINT:
671 case Types.INTEGER:
672 case Types.BIGINT:
673 case Types.FLOAT:
674 case Types.REAL:
675 case Types.DOUBLE:
676 case Types.NUMERIC:
677 case Types.DECIMAL:
678 return !f.isUnsigned();
679
680 case Types.DATE:
681 case Types.TIME:
682 case Types.TIMESTAMP:
683 return false;
684
685 default:
686 return false;
687 }
688 }
689
690 /**
691 * Is it possible for a write on the column to succeed?
692 *
693 * @param column
694 * the first column is 1, the second is 2, etc.
695 *
696 * @return true if so
697 *
698 * @throws SQLException
699 * if a database access error occurs
700 */
701 public boolean isWritable(int column) throws SQLException {
702 return !isReadOnly(column);
703 }
704
705 /**
706 * Returns a string representation of this object
707 *
708 * @return ...
709 */
710 public String toString() {
711 StringBuffer toStringBuf = new StringBuffer();
712 toStringBuf.append(super.toString());
713 toStringBuf.append(" - Field level information: "); //$NON-NLS-1$
714
715 for (int i = 0; i < this.fields.length; i++) {
716 toStringBuf.append("\n\t"); //$NON-NLS-1$
717 toStringBuf.append(this.fields[i].toString());
718 }
719
720 return toStringBuf.toString();
721 }
722
723 static String getClassNameForJavaType(int javaType,
724 boolean isUnsigned, int mysqlTypeIfKnown,
725 boolean isBinaryOrBlob,
726 boolean isOpaqueBinary) {
727 switch (javaType) {
728 case Types.BIT:
729 case Types.BOOLEAN:
730 return "java.lang.Boolean"; //$NON-NLS-1$
731
732 case Types.TINYINT:
733
734 if (isUnsigned) {
735 return "java.lang.Integer"; //$NON-NLS-1$
736 }
737
738 return "java.lang.Integer"; //$NON-NLS-1$
739
740 case Types.SMALLINT:
741
742 if (isUnsigned) {
743 return "java.lang.Integer"; //$NON-NLS-1$
744 }
745
746 return "java.lang.Integer"; //$NON-NLS-1$
747
748 case Types.INTEGER:
749
750 if (!isUnsigned ||
751 mysqlTypeIfKnown == MysqlDefs.FIELD_TYPE_INT24) {
752 return "java.lang.Integer"; //$NON-NLS-1$
753 }
754
755 return "java.lang.Long"; //$NON-NLS-1$
756
757 case Types.BIGINT:
758
759 if (!isUnsigned) {
760 return "java.lang.Long"; //$NON-NLS-1$
761 }
762
763 return "java.math.BigInteger"; //$NON-NLS-1$
764
765 case Types.DECIMAL:
766 case Types.NUMERIC:
767 return "java.math.BigDecimal"; //$NON-NLS-1$
768
769 case Types.REAL:
770 return "java.lang.Float"; //$NON-NLS-1$
771
772 case Types.FLOAT:
773 case Types.DOUBLE:
774 return "java.lang.Double"; //$NON-NLS-1$
775
776 case Types.CHAR:
777 case Types.VARCHAR:
778 case Types.LONGVARCHAR:
779 if (!isOpaqueBinary) {
780 return "java.lang.String"; //$NON-NLS-1$
781 }
782
783 return "[B";
784
785 case Types.BINARY:
786 case Types.VARBINARY:
787 case Types.LONGVARBINARY:
788
789 if (mysqlTypeIfKnown == MysqlDefs.FIELD_TYPE_GEOMETRY) {
790 return "[B";
791 } else if (isBinaryOrBlob) {
792 return "[B";
793 } else {
794 return "java.lang.String";
795 }
796
797 case Types.DATE:
798 return "java.sql.Date"; //$NON-NLS-1$
799
800 case Types.TIME:
801 return "java.sql.Time"; //$NON-NLS-1$
802
803 case Types.TIMESTAMP:
804 return "java.sql.Timestamp"; //$NON-NLS-1$
805
806 default:
807 return "java.lang.Object"; //$NON-NLS-1$
808 }
809 }
810
811 /**
812 * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
813 * for an object that does. Returns false otherwise. If this implements the interface then return true,
814 * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
815 * object. If this does not implement the interface and is not a wrapper, return false.
816 * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
817 * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
818 * returns true then calling <code>unwrap</code> with the same argument should succeed.
819 *
820 * @param interfaces a Class defining an interface.
821 * @return true if this implements the interface or directly or indirectly wraps an object that does.
822 * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
823 * for an object with the given interface.
824 * @since 1.6
825 */
826 public boolean isWrapperFor(Class iface) throws SQLException {
827 // This works for classes that aren't actually wrapping
828 // anything
829 return iface.isInstance(this);
830 }
831
832 /**
833 * Returns an object that implements the given interface to allow access to non-standard methods,
834 * or standard methods not exposed by the proxy.
835 * The result may be either the object found to implement the interface or a proxy for that object.
836 * If the receiver implements the interface then that is the object. If the receiver is a wrapper
837 * and the wrapped object implements the interface then that is the object. Otherwise the object is
838 * the result of calling <code>unwrap</code> recursively on the wrapped object. If the receiver is not a
839 * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
840 *
841 * @param iface A Class defining an interface that the result must implement.
842 * @return an object that implements the interface. May be a proxy for the actual implementing object.
843 * @throws java.sql.SQLException If no object found that implements the interface
844 * @since 1.6
845 */
846 public Object unwrap(Class iface) throws java.sql.SQLException {
847 try {
848 // This works for classes that aren't actually wrapping
849 // anything
850 return Util.cast(iface, this);
851 } catch (ClassCastException cce) {
852 throw SQLError.createSQLException("Unable to unwrap to " + iface.toString(),
853 SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
854 }
855 }
856 }