001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     * 
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     * 
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    
018    package org.apache.commons.dbcp;
019    
020    import java.sql.Connection;
021    import java.sql.DatabaseMetaData;
022    import java.sql.ResultSet;
023    /*
024    import java.sql.RowIdLifetime;
025    */
026    import java.sql.SQLException;
027    
028    /**
029     * A base delegating implementation of {@link DatabaseMetaData}.
030     * <p>
031     * Those methods that create {@link ResultSet} objects, are wrapped to
032     * create {@link DelegatingResultSet} objects and the remaining methods
033     * simply call the corresponding method on the "delegate"
034     * provided in my constructor.
035     * <p>
036     * Extends AbandonedTrace to implement DatabaseMetaData tracking and
037     * logging of code which created the DatabaseMetaData. Tracking
038     * the DatabaseMetaData ensures that the Connection which created it can
039     * close any associated ResultSets on Connection close.
040     */
041    public class DelegatingDatabaseMetaData extends AbandonedTrace
042            implements DatabaseMetaData {
043    
044        /** My delegate {@link DatabaseMetaData} */
045        protected DatabaseMetaData _meta;
046        
047        /** The connection that created me. **/
048        protected DelegatingConnection _conn = null;
049    
050        public DelegatingDatabaseMetaData(DelegatingConnection c,
051                DatabaseMetaData m) {
052            super(c);
053            _conn = c;
054            _meta = m;
055        }
056    
057        public DatabaseMetaData getDelegate() {
058            return _meta;
059        }
060    
061        public boolean equals(Object obj) {
062            DatabaseMetaData delegate = getInnermostDelegate();
063            if (delegate == null) {
064                return false;
065            }
066            if (obj instanceof DelegatingDatabaseMetaData) {
067                DelegatingDatabaseMetaData s = (DelegatingDatabaseMetaData) obj;
068                return delegate.equals(s.getInnermostDelegate());
069            }
070            else {
071                return delegate.equals(obj);
072            }
073        }
074    
075        public int hashCode() {
076            Object obj = getInnermostDelegate();
077            if (obj == null) {
078                return 0;
079            }
080            return obj.hashCode();
081        }
082    
083        /**
084         * If my underlying {@link ResultSet} is not a
085         * <tt>DelegatingResultSet</tt>, returns it,
086         * otherwise recursively invokes this method on
087         * my delegate.
088         * <p>
089         * Hence this method will return the first
090         * delegate that is not a <tt>DelegatingResultSet</tt>,
091         * or <tt>null</tt> when no non-<tt>DelegatingResultSet</tt>
092         * delegate can be found by transversing this chain.
093         * <p>
094         * This method is useful when you may have nested
095         * <tt>DelegatingResultSet</tt>s, and you want to make
096         * sure to obtain a "genuine" {@link ResultSet}.
097         */
098        public DatabaseMetaData getInnermostDelegate() {
099            DatabaseMetaData m = _meta;
100            while(m != null && m instanceof DelegatingDatabaseMetaData) {
101                m = ((DelegatingDatabaseMetaData)m).getDelegate();
102                if(this == m) {
103                    return null;
104                }
105            }
106            return m;
107        }
108        
109        protected void handleException(SQLException e) throws SQLException {
110            if (_conn != null) {
111                _conn.handleException(e);
112            }
113            else {
114                throw e;
115            }
116        }
117    
118        public boolean allProceduresAreCallable() throws SQLException {
119            { try { return _meta.allProceduresAreCallable(); }
120              catch (SQLException e) { handleException(e); return false; } }
121        }
122    
123        public boolean allTablesAreSelectable() throws SQLException {
124            { try { return _meta.allTablesAreSelectable(); }
125            catch (SQLException e) { handleException(e); return false; } }
126        }
127    
128        public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
129            { try { return _meta.dataDefinitionCausesTransactionCommit(); }
130            catch (SQLException e) { handleException(e); return false; } }
131        }
132    
133        public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
134            { try { return _meta.dataDefinitionIgnoredInTransactions(); }
135            catch (SQLException e) { handleException(e); return false; } }
136        }
137    
138        public boolean deletesAreDetected(int type) throws SQLException {
139            { try { return _meta.deletesAreDetected(type); }
140            catch (SQLException e) { handleException(e); return false; } }
141        }
142    
143        public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
144            { try { return _meta.doesMaxRowSizeIncludeBlobs(); }
145            catch (SQLException e) { handleException(e); return false; } }
146        }
147    
148        public ResultSet getAttributes(String catalog, String schemaPattern,
149                String typeNamePattern, String attributeNamePattern)
150                throws SQLException {
151            _conn.checkOpen();
152            try {
153                return DelegatingResultSet.wrapResultSet(_conn,_meta.getAttributes(
154                        catalog, schemaPattern, typeNamePattern,
155                        attributeNamePattern));
156            }
157            catch (SQLException e) {
158                handleException(e);
159                throw new AssertionError();
160            }
161        }
162    
163        public ResultSet getBestRowIdentifier(String catalog, String schema,
164                String table, int scope, boolean nullable) throws SQLException {
165            _conn.checkOpen();
166            try {
167                return DelegatingResultSet.wrapResultSet(_conn,
168                        _meta.getBestRowIdentifier(catalog, schema, table, scope,
169                                nullable));
170            }
171            catch (SQLException e) {
172                handleException(e);
173                throw new AssertionError();
174            }
175        }
176    
177        public String getCatalogSeparator() throws SQLException {
178            { try { return _meta.getCatalogSeparator(); }
179            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
180        }
181    
182        public String getCatalogTerm() throws SQLException {
183            { try { return _meta.getCatalogTerm(); }
184            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
185        }
186    
187        public ResultSet getCatalogs() throws SQLException {
188            _conn.checkOpen();
189            try {
190                return DelegatingResultSet.wrapResultSet(_conn,
191                        _meta.getCatalogs());
192            }
193            catch (SQLException e) {
194                handleException(e);
195                throw new AssertionError();
196            }
197        }
198    
199        public ResultSet getColumnPrivileges(String catalog, String schema,
200                String table, String columnNamePattern) throws SQLException {
201            _conn.checkOpen();
202            try {
203                return DelegatingResultSet.wrapResultSet(_conn,
204                        _meta.getColumnPrivileges(catalog, schema, table,
205                                columnNamePattern));
206            }
207            catch (SQLException e) {
208                handleException(e);
209                throw new AssertionError();
210            }
211        }
212    
213        public ResultSet getColumns(String catalog, String schemaPattern,
214                String tableNamePattern, String columnNamePattern)
215                throws SQLException {
216            _conn.checkOpen();
217            try {
218                return DelegatingResultSet.wrapResultSet(_conn,
219                        _meta.getColumns(catalog, schemaPattern, tableNamePattern,
220                                columnNamePattern));
221            }
222            catch (SQLException e) {
223                handleException(e);
224                throw new AssertionError();
225            }
226        }
227    
228        public Connection getConnection() throws SQLException {
229            return _conn;
230        }
231    
232        public ResultSet getCrossReference(String parentCatalog,
233                String parentSchema, String parentTable, String foreignCatalog,
234                String foreignSchema, String foreignTable) throws SQLException {
235            _conn.checkOpen();
236            try {
237                return DelegatingResultSet.wrapResultSet(_conn,
238                        _meta.getCrossReference(parentCatalog, parentSchema,
239                                parentTable, foreignCatalog, foreignSchema,
240                                foreignTable));
241            }
242            catch (SQLException e) {
243                handleException(e);
244                throw new AssertionError();
245            }
246        }
247    
248        public int getDatabaseMajorVersion() throws SQLException {
249            { try { return _meta.getDatabaseMajorVersion(); }
250            catch (SQLException e) { handleException(e); return 0; } }
251        }
252    
253        public int getDatabaseMinorVersion() throws SQLException {
254            { try { return _meta.getDatabaseMinorVersion(); }
255            catch (SQLException e) { handleException(e); return 0; } }
256        }
257    
258        public String getDatabaseProductName() throws SQLException {
259            { try { return _meta.getDatabaseProductName(); }
260            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
261        }
262    
263        public String getDatabaseProductVersion() throws SQLException {
264            { try { return _meta.getDatabaseProductVersion(); }
265            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
266        }
267    
268        public int getDefaultTransactionIsolation() throws SQLException {
269            { try { return _meta.getDefaultTransactionIsolation(); }
270            catch (SQLException e) { handleException(e); return 0; } }
271        }
272    
273        public int getDriverMajorVersion() {return _meta.getDriverMajorVersion();}
274    
275        public int getDriverMinorVersion() {return _meta.getDriverMinorVersion();}
276    
277        public String getDriverName() throws SQLException {
278            { try { return _meta.getDriverName(); }
279            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
280        }
281    
282        public String getDriverVersion() throws SQLException {
283            { try { return _meta.getDriverVersion(); }
284            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
285        }
286    
287        public ResultSet getExportedKeys(String catalog, String schema, String table)
288                throws SQLException {
289            _conn.checkOpen();
290            try {
291                return DelegatingResultSet.wrapResultSet(_conn,
292                        _meta.getExportedKeys(catalog, schema, table));
293            }
294            catch (SQLException e) {
295                handleException(e);
296                throw new AssertionError();
297            }
298        }
299    
300        public String getExtraNameCharacters() throws SQLException {
301            { try { return _meta.getExtraNameCharacters(); }
302            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
303        }
304    
305        public String getIdentifierQuoteString() throws SQLException {
306            { try { return _meta.getIdentifierQuoteString(); }
307            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
308        }
309    
310        public ResultSet getImportedKeys(String catalog, String schema, String table)
311                throws SQLException {
312            _conn.checkOpen();
313            try {
314                return DelegatingResultSet.wrapResultSet(_conn,
315                        _meta.getImportedKeys(catalog, schema, table));
316            }
317            catch (SQLException e) {
318                handleException(e);
319                throw new AssertionError();
320            }
321        }
322    
323        public ResultSet getIndexInfo(String catalog, String schema, String table,
324                boolean unique, boolean approximate) throws SQLException {
325            _conn.checkOpen();
326            try {
327                return DelegatingResultSet.wrapResultSet(_conn,
328                        _meta.getIndexInfo(catalog, schema, table, unique,
329                                approximate));
330            }
331            catch (SQLException e) {
332                handleException(e);
333                throw new AssertionError();
334            }
335        }
336    
337        public int getJDBCMajorVersion() throws SQLException {
338            { try { return _meta.getJDBCMajorVersion(); }
339            catch (SQLException e) { handleException(e); return 0; } }
340        }
341    
342        public int getJDBCMinorVersion() throws SQLException {
343            { try { return _meta.getJDBCMinorVersion(); }
344            catch (SQLException e) { handleException(e); return 0; } }
345        }
346    
347        public int getMaxBinaryLiteralLength() throws SQLException {
348            { try { return _meta.getMaxBinaryLiteralLength(); }
349            catch (SQLException e) { handleException(e); return 0; } }
350        }
351    
352        public int getMaxCatalogNameLength() throws SQLException {
353            { try { return _meta.getMaxCatalogNameLength(); }
354            catch (SQLException e) { handleException(e); return 0; } }
355        }
356    
357        public int getMaxCharLiteralLength() throws SQLException {
358            { try { return _meta.getMaxCharLiteralLength(); }
359            catch (SQLException e) { handleException(e); return 0; } }
360        }
361    
362        public int getMaxColumnNameLength() throws SQLException {
363            { try { return _meta.getMaxColumnNameLength(); }
364            catch (SQLException e) { handleException(e); return 0; } }
365        }
366    
367        public int getMaxColumnsInGroupBy() throws SQLException {
368            { try { return _meta.getMaxColumnsInGroupBy(); }
369            catch (SQLException e) { handleException(e); return 0; } }
370        }
371    
372        public int getMaxColumnsInIndex() throws SQLException {
373            { try { return _meta.getMaxColumnsInIndex(); }
374            catch (SQLException e) { handleException(e); return 0; } }
375        }
376    
377        public int getMaxColumnsInOrderBy() throws SQLException {
378            { try { return _meta.getMaxColumnsInOrderBy(); }
379            catch (SQLException e) { handleException(e); return 0; } }
380        }
381    
382        public int getMaxColumnsInSelect() throws SQLException {
383            { try { return _meta.getMaxColumnsInSelect(); }
384            catch (SQLException e) { handleException(e); return 0; } }
385        }
386    
387        public int getMaxColumnsInTable() throws SQLException {
388            { try { return _meta.getMaxColumnsInTable(); }
389            catch (SQLException e) { handleException(e); return 0; } }
390        }
391    
392        public int getMaxConnections() throws SQLException {
393            { try { return _meta.getMaxConnections(); }
394            catch (SQLException e) { handleException(e); return 0; } }
395        }
396    
397        public int getMaxCursorNameLength() throws SQLException {
398            { try { return _meta.getMaxCursorNameLength(); }
399            catch (SQLException e) { handleException(e); return 0; } }
400        }
401    
402        public int getMaxIndexLength() throws SQLException {
403            { try { return _meta.getMaxIndexLength(); }
404            catch (SQLException e) { handleException(e); return 0; } }
405        }
406    
407        public int getMaxProcedureNameLength() throws SQLException {
408            { try { return _meta.getMaxProcedureNameLength(); }
409            catch (SQLException e) { handleException(e); return 0; } }
410        }
411    
412        public int getMaxRowSize() throws SQLException {
413            { try { return _meta.getMaxRowSize(); }
414            catch (SQLException e) { handleException(e); return 0; } }
415        }
416    
417        public int getMaxSchemaNameLength() throws SQLException {
418            { try { return _meta.getMaxSchemaNameLength(); }
419            catch (SQLException e) { handleException(e); return 0; } }
420        }
421    
422        public int getMaxStatementLength() throws SQLException {
423            { try { return _meta.getMaxStatementLength(); }
424            catch (SQLException e) { handleException(e); return 0; } }
425        }
426    
427        public int getMaxStatements() throws SQLException {
428            { try { return _meta.getMaxStatements(); }
429            catch (SQLException e) { handleException(e); return 0; } }
430        }
431    
432        public int getMaxTableNameLength() throws SQLException {
433            { try { return _meta.getMaxTableNameLength(); }
434            catch (SQLException e) { handleException(e); return 0; } }
435        }
436    
437        public int getMaxTablesInSelect() throws SQLException {
438            { try { return _meta.getMaxTablesInSelect(); }
439            catch (SQLException e) { handleException(e); return 0; } }
440        }
441    
442        public int getMaxUserNameLength() throws SQLException {
443            { try { return _meta.getMaxUserNameLength(); }
444            catch (SQLException e) { handleException(e); return 0; } }
445        }
446    
447        public String getNumericFunctions() throws SQLException {
448            { try { return _meta.getNumericFunctions(); }
449            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
450        }
451    
452        public ResultSet getPrimaryKeys(String catalog, String schema, String table)
453                throws SQLException {
454            _conn.checkOpen();
455            try {
456                return DelegatingResultSet.wrapResultSet(_conn,
457                        _meta.getPrimaryKeys(catalog, schema, table));
458            }
459            catch (SQLException e) {
460                handleException(e);
461                throw new AssertionError();
462            }
463        }
464    
465        public ResultSet getProcedureColumns(String catalog, String schemaPattern,
466                String procedureNamePattern, String columnNamePattern)
467                throws SQLException {
468            _conn.checkOpen();
469            try {
470                return DelegatingResultSet.wrapResultSet(_conn,
471                        _meta.getProcedureColumns(catalog, schemaPattern,
472                                procedureNamePattern, columnNamePattern));
473            }
474            catch (SQLException e) {
475                handleException(e);
476                throw new AssertionError();
477            }
478        }
479    
480        public String getProcedureTerm() throws SQLException {
481            { try { return _meta.getProcedureTerm(); }
482            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
483        }
484    
485        public ResultSet getProcedures(String catalog, String schemaPattern,
486                String procedureNamePattern) throws SQLException {
487            _conn.checkOpen();
488            try {
489                return DelegatingResultSet.wrapResultSet(_conn,
490                        _meta.getProcedures(catalog, schemaPattern,
491                                procedureNamePattern));
492            }
493            catch (SQLException e) {
494                handleException(e);
495                throw new AssertionError();
496            }
497        }
498    
499        public int getResultSetHoldability() throws SQLException {
500            { try { return _meta.getResultSetHoldability(); }
501            catch (SQLException e) { handleException(e); return 0; } }
502        }
503    
504        public String getSQLKeywords() throws SQLException {
505            { try { return _meta.getSQLKeywords(); }
506            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
507        }
508    
509        public int getSQLStateType() throws SQLException {
510            { try { return _meta.getSQLStateType(); }
511            catch (SQLException e) { handleException(e); return 0; } }
512        }
513    
514        public String getSchemaTerm() throws SQLException {
515            { try { return _meta.getSchemaTerm(); }
516            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
517        }
518    
519        public ResultSet getSchemas() throws SQLException {
520            _conn.checkOpen();
521            try {
522                return DelegatingResultSet.wrapResultSet(_conn,
523                        _meta.getSchemas());
524            }
525            catch (SQLException e) {
526                handleException(e);
527                throw new AssertionError();
528            }
529        }
530    
531        public String getSearchStringEscape() throws SQLException {
532            { try { return _meta.getSearchStringEscape(); }
533            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
534        }
535    
536        public String getStringFunctions() throws SQLException {
537            { try { return _meta.getStringFunctions(); }
538            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
539        }
540    
541        public ResultSet getSuperTables(String catalog, String schemaPattern,
542                String tableNamePattern) throws SQLException {
543            _conn.checkOpen();
544            try {
545                return DelegatingResultSet.wrapResultSet(_conn,
546                        _meta.getSuperTables(catalog, schemaPattern,
547                                tableNamePattern));
548            }
549            catch (SQLException e) {
550                handleException(e);
551                throw new AssertionError();
552            }
553        }
554    
555        public ResultSet getSuperTypes(String catalog, String schemaPattern,
556                String typeNamePattern) throws SQLException {
557            _conn.checkOpen();
558            try {
559                return DelegatingResultSet.wrapResultSet(_conn,
560                        _meta.getSuperTypes(catalog, schemaPattern,
561                                typeNamePattern));
562            }
563            catch (SQLException e) {
564                handleException(e);
565                throw new AssertionError();
566            }
567        }
568    
569        public String getSystemFunctions() throws SQLException {
570            { try { return _meta.getSystemFunctions(); }
571            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
572        }
573    
574        public ResultSet getTablePrivileges(String catalog, String schemaPattern,
575                String tableNamePattern) throws SQLException {
576            _conn.checkOpen();
577            try {
578                return DelegatingResultSet.wrapResultSet(_conn,
579                        _meta.getTablePrivileges(catalog, schemaPattern,
580                                tableNamePattern));
581            }
582            catch (SQLException e) {
583                handleException(e);
584                throw new AssertionError();
585            }
586        }
587    
588        public ResultSet getTableTypes() throws SQLException {
589            _conn.checkOpen();
590            try {
591                return DelegatingResultSet.wrapResultSet(_conn,
592                        _meta.getTableTypes());
593            }
594            catch (SQLException e) {
595                handleException(e);
596                throw new AssertionError();
597            }
598        }
599    
600        public ResultSet getTables(String catalog, String schemaPattern,
601                String tableNamePattern, String[] types) throws SQLException {
602            _conn.checkOpen();
603            try {
604                return DelegatingResultSet.wrapResultSet(_conn,
605                        _meta.getTables(catalog, schemaPattern, tableNamePattern,
606                                types));
607            }
608            catch (SQLException e) {
609                handleException(e);
610                throw new AssertionError();
611            }
612        }
613    
614        public String getTimeDateFunctions() throws SQLException {
615            { try { return _meta.getTimeDateFunctions(); }
616            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
617        }
618    
619        public ResultSet getTypeInfo() throws SQLException {
620            _conn.checkOpen();
621            try {
622                return DelegatingResultSet.wrapResultSet(_conn,
623                        _meta.getTypeInfo());
624            }
625            catch (SQLException e) {
626                handleException(e);
627                throw new AssertionError();
628            }
629        }
630    
631        public ResultSet getUDTs(String catalog, String schemaPattern,
632                String typeNamePattern, int[] types) throws SQLException {
633            _conn.checkOpen();
634            try {
635                return DelegatingResultSet.wrapResultSet(_conn,
636                        _meta.getUDTs(catalog, schemaPattern, typeNamePattern,
637                                types));
638            }
639            catch (SQLException e) {
640                handleException(e);
641                throw new AssertionError();
642            }
643        }
644    
645        public String getURL() throws SQLException {
646            { try { return _meta.getURL(); }
647            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
648        }
649    
650        public String getUserName() throws SQLException {
651            { try { return _meta.getUserName(); }
652            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
653        }
654    
655        public ResultSet getVersionColumns(String catalog, String schema,
656                String table) throws SQLException {
657            _conn.checkOpen();
658            try {
659                return DelegatingResultSet.wrapResultSet(_conn,
660                        _meta.getVersionColumns(catalog, schema, table));
661            }
662            catch (SQLException e) {
663                handleException(e);
664                throw new AssertionError();
665            }
666        }
667    
668        public boolean insertsAreDetected(int type) throws SQLException {
669            { try { return _meta.insertsAreDetected(type); }
670            catch (SQLException e) { handleException(e); return false; } }
671        }
672    
673        public boolean isCatalogAtStart() throws SQLException {
674            { try { return _meta.isCatalogAtStart(); }
675            catch (SQLException e) { handleException(e); return false; } }
676        }
677    
678        public boolean isReadOnly() throws SQLException {
679            { try { return _meta.isReadOnly(); }
680            catch (SQLException e) { handleException(e); return false; } }
681        }
682    
683        public boolean locatorsUpdateCopy() throws SQLException {
684            { try { return _meta.locatorsUpdateCopy(); }
685            catch (SQLException e) { handleException(e); return false; } }
686        }
687    
688        public boolean nullPlusNonNullIsNull() throws SQLException {
689            { try { return _meta.nullPlusNonNullIsNull(); }
690            catch (SQLException e) { handleException(e); return false; } }
691        }
692    
693        public boolean nullsAreSortedAtEnd() throws SQLException {
694            { try { return _meta.nullsAreSortedAtEnd(); }
695            catch (SQLException e) { handleException(e); return false; } }
696        }
697    
698        public boolean nullsAreSortedAtStart() throws SQLException {
699            { try { return _meta.nullsAreSortedAtStart(); }
700            catch (SQLException e) { handleException(e); return false; } }
701        }
702    
703        public boolean nullsAreSortedHigh() throws SQLException {
704            { try { return _meta.nullsAreSortedHigh(); }
705            catch (SQLException e) { handleException(e); return false; } }
706        }
707    
708        public boolean nullsAreSortedLow() throws SQLException {
709            { try { return _meta.nullsAreSortedLow(); }
710            catch (SQLException e) { handleException(e); return false; } }
711        }
712    
713        public boolean othersDeletesAreVisible(int type) throws SQLException {
714            { try { return _meta.othersDeletesAreVisible(type); }
715            catch (SQLException e) { handleException(e); return false; } }
716        }
717    
718        public boolean othersInsertsAreVisible(int type) throws SQLException {
719            { try { return _meta.othersInsertsAreVisible(type); }
720            catch (SQLException e) { handleException(e); return false; } }
721        }
722    
723        public boolean othersUpdatesAreVisible(int type) throws SQLException {
724            { try { return _meta.othersUpdatesAreVisible(type); }
725            catch (SQLException e) { handleException(e); return false; } }
726        }
727    
728        public boolean ownDeletesAreVisible(int type) throws SQLException {
729            { try { return _meta.ownDeletesAreVisible(type); }
730            catch (SQLException e) { handleException(e); return false; } }
731        }
732    
733        public boolean ownInsertsAreVisible(int type) throws SQLException {
734            { try { return _meta.ownInsertsAreVisible(type); }
735            catch (SQLException e) { handleException(e); return false; } }
736        }
737    
738        public boolean ownUpdatesAreVisible(int type) throws SQLException {
739            { try { return _meta.ownUpdatesAreVisible(type); }
740            catch (SQLException e) { handleException(e); return false; } }
741        }
742    
743        public boolean storesLowerCaseIdentifiers() throws SQLException {
744            { try { return _meta.storesLowerCaseIdentifiers(); }
745            catch (SQLException e) { handleException(e); return false; } }
746        }
747    
748        public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
749            { try { return _meta.storesLowerCaseQuotedIdentifiers(); }
750            catch (SQLException e) { handleException(e); return false; } }
751        }
752    
753        public boolean storesMixedCaseIdentifiers() throws SQLException {
754            { try { return _meta.storesMixedCaseIdentifiers(); }
755            catch (SQLException e) { handleException(e); return false; } }
756        }
757    
758        public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
759            { try { return _meta.storesMixedCaseQuotedIdentifiers(); }
760            catch (SQLException e) { handleException(e); return false; } }
761        }
762    
763        public boolean storesUpperCaseIdentifiers() throws SQLException {
764            { try { return _meta.storesUpperCaseIdentifiers(); }
765            catch (SQLException e) { handleException(e); return false; } }
766        }
767    
768        public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
769            { try { return _meta.storesUpperCaseQuotedIdentifiers(); }
770            catch (SQLException e) { handleException(e); return false; } }
771        }
772    
773        public boolean supportsANSI92EntryLevelSQL() throws SQLException {
774            { try { return _meta.supportsANSI92EntryLevelSQL(); }
775            catch (SQLException e) { handleException(e); return false; } }
776        }
777    
778        public boolean supportsANSI92FullSQL() throws SQLException {
779            { try { return _meta.supportsANSI92FullSQL(); }
780            catch (SQLException e) { handleException(e); return false; } }
781        }
782    
783        public boolean supportsANSI92IntermediateSQL() throws SQLException {
784            { try { return _meta.supportsANSI92IntermediateSQL(); }
785            catch (SQLException e) { handleException(e); return false; } }
786        }
787    
788        public boolean supportsAlterTableWithAddColumn() throws SQLException {
789            { try { return _meta.supportsAlterTableWithAddColumn(); }
790            catch (SQLException e) { handleException(e); return false; } }
791        }
792    
793        public boolean supportsAlterTableWithDropColumn() throws SQLException {
794            { try { return _meta.supportsAlterTableWithDropColumn(); }
795            catch (SQLException e) { handleException(e); return false; } }
796        }
797    
798        public boolean supportsBatchUpdates() throws SQLException {
799            { try { return _meta.supportsBatchUpdates(); }
800            catch (SQLException e) { handleException(e); return false; } }
801        }
802    
803        public boolean supportsCatalogsInDataManipulation() throws SQLException {
804            { try { return _meta.supportsCatalogsInDataManipulation(); }
805            catch (SQLException e) { handleException(e); return false; } }
806        }
807    
808        public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
809            { try { return _meta.supportsCatalogsInIndexDefinitions(); }
810            catch (SQLException e) { handleException(e); return false; } }
811        }
812    
813        public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
814            { try { return _meta.supportsCatalogsInPrivilegeDefinitions(); }
815            catch (SQLException e) { handleException(e); return false; } }
816        }
817    
818        public boolean supportsCatalogsInProcedureCalls() throws SQLException {
819            { try { return _meta.supportsCatalogsInProcedureCalls(); }
820            catch (SQLException e) { handleException(e); return false; } }
821        }
822    
823        public boolean supportsCatalogsInTableDefinitions() throws SQLException {
824            { try { return _meta.supportsCatalogsInTableDefinitions(); }
825            catch (SQLException e) { handleException(e); return false; } }
826        }
827    
828        public boolean supportsColumnAliasing() throws SQLException {
829            { try { return _meta.supportsColumnAliasing(); }
830            catch (SQLException e) { handleException(e); return false; } }
831        }
832    
833        public boolean supportsConvert() throws SQLException {
834            { try { return _meta.supportsConvert(); }
835            catch (SQLException e) { handleException(e); return false; } }
836        }
837    
838        public boolean supportsConvert(int fromType, int toType)
839                throws SQLException {
840            { try { return _meta.supportsConvert(fromType, toType); }
841            catch (SQLException e) { handleException(e); return false; } }
842        }
843    
844        public boolean supportsCoreSQLGrammar() throws SQLException {
845            { try { return _meta.supportsCoreSQLGrammar(); }
846            catch (SQLException e) { handleException(e); return false; } }
847        }
848    
849        public boolean supportsCorrelatedSubqueries() throws SQLException {
850            { try { return _meta.supportsCorrelatedSubqueries(); }
851            catch (SQLException e) { handleException(e); return false; } }
852        }
853    
854        public boolean supportsDataDefinitionAndDataManipulationTransactions()
855                throws SQLException {
856            { try { return _meta.supportsDataDefinitionAndDataManipulationTransactions(); }
857            catch (SQLException e) { handleException(e); return false; } }
858        }
859    
860        public boolean supportsDataManipulationTransactionsOnly()
861                throws SQLException {
862            { try { return _meta.supportsDataManipulationTransactionsOnly(); }
863            catch (SQLException e) { handleException(e); return false; } }
864        }
865    
866        public boolean supportsDifferentTableCorrelationNames() throws SQLException {
867            { try { return _meta.supportsDifferentTableCorrelationNames(); }
868            catch (SQLException e) { handleException(e); return false; } }
869        }
870    
871        public boolean supportsExpressionsInOrderBy() throws SQLException {
872            { try { return _meta.supportsExpressionsInOrderBy(); }
873            catch (SQLException e) { handleException(e); return false; } }
874        }
875    
876        public boolean supportsExtendedSQLGrammar() throws SQLException {
877            { try { return _meta.supportsExtendedSQLGrammar(); }
878            catch (SQLException e) { handleException(e); return false; } }
879        }
880    
881        public boolean supportsFullOuterJoins() throws SQLException {
882            { try { return _meta.supportsFullOuterJoins(); }
883            catch (SQLException e) { handleException(e); return false; } }
884        }
885    
886        public boolean supportsGetGeneratedKeys() throws SQLException {
887            { try { return _meta.supportsGetGeneratedKeys(); }
888            catch (SQLException e) { handleException(e); return false; } }
889        }
890    
891        public boolean supportsGroupBy() throws SQLException {
892            { try { return _meta.supportsGroupBy(); }
893            catch (SQLException e) { handleException(e); return false; } }
894        }
895    
896        public boolean supportsGroupByBeyondSelect() throws SQLException {
897            { try { return _meta.supportsGroupByBeyondSelect(); }
898            catch (SQLException e) { handleException(e); return false; } }
899        }
900    
901        public boolean supportsGroupByUnrelated() throws SQLException {
902            { try { return _meta.supportsGroupByUnrelated(); }
903            catch (SQLException e) { handleException(e); return false; } }
904        }
905    
906        public boolean supportsIntegrityEnhancementFacility() throws SQLException {
907            { try { return _meta.supportsIntegrityEnhancementFacility(); }
908            catch (SQLException e) { handleException(e); return false; } }
909        }
910    
911        public boolean supportsLikeEscapeClause() throws SQLException {
912            { try { return _meta.supportsLikeEscapeClause(); }
913            catch (SQLException e) { handleException(e); return false; } }
914        }
915    
916        public boolean supportsLimitedOuterJoins() throws SQLException {
917            { try { return _meta.supportsLimitedOuterJoins(); }
918            catch (SQLException e) { handleException(e); return false; } }
919        }
920    
921        public boolean supportsMinimumSQLGrammar() throws SQLException {
922            { try { return _meta.supportsMinimumSQLGrammar(); }
923            catch (SQLException e) { handleException(e); return false; } }
924        }
925    
926        public boolean supportsMixedCaseIdentifiers() throws SQLException {
927            { try { return _meta.supportsMixedCaseIdentifiers(); }
928            catch (SQLException e) { handleException(e); return false; } }
929        }
930    
931        public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
932            { try { return _meta.supportsMixedCaseQuotedIdentifiers(); }
933            catch (SQLException e) { handleException(e); return false; } }
934        }
935    
936        public boolean supportsMultipleOpenResults() throws SQLException {
937            { try { return _meta.supportsMultipleOpenResults(); }
938            catch (SQLException e) { handleException(e); return false; } }
939        }
940    
941        public boolean supportsMultipleResultSets() throws SQLException {
942            { try { return _meta.supportsMultipleResultSets(); }
943            catch (SQLException e) { handleException(e); return false; } }
944        }
945    
946        public boolean supportsMultipleTransactions() throws SQLException {
947            { try { return _meta.supportsMultipleTransactions(); }
948            catch (SQLException e) { handleException(e); return false; } }
949        }
950    
951        public boolean supportsNamedParameters() throws SQLException {
952            { try { return _meta.supportsNamedParameters(); }
953            catch (SQLException e) { handleException(e); return false; } }
954        }
955    
956        public boolean supportsNonNullableColumns() throws SQLException {
957            { try { return _meta.supportsNonNullableColumns(); }
958            catch (SQLException e) { handleException(e); return false; } }
959        }
960    
961        public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
962            { try { return _meta.supportsOpenCursorsAcrossCommit(); }
963            catch (SQLException e) { handleException(e); return false; } }
964        }
965    
966        public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
967            { try { return _meta.supportsOpenCursorsAcrossRollback(); }
968            catch (SQLException e) { handleException(e); return false; } }
969        }
970    
971        public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
972            { try { return _meta.supportsOpenStatementsAcrossCommit(); }
973            catch (SQLException e) { handleException(e); return false; } }
974        }
975    
976        public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
977            { try { return _meta.supportsOpenStatementsAcrossRollback(); }
978            catch (SQLException e) { handleException(e); return false; } }
979        }
980    
981        public boolean supportsOrderByUnrelated() throws SQLException {
982            { try { return _meta.supportsOrderByUnrelated(); }
983            catch (SQLException e) { handleException(e); return false; } }
984        }
985    
986        public boolean supportsOuterJoins() throws SQLException {
987            { try { return _meta.supportsOuterJoins(); }
988            catch (SQLException e) { handleException(e); return false; } }
989        }
990    
991        public boolean supportsPositionedDelete() throws SQLException {
992            { try { return _meta.supportsPositionedDelete(); }
993            catch (SQLException e) { handleException(e); return false; } }
994        }
995    
996        public boolean supportsPositionedUpdate() throws SQLException {
997            { try { return _meta.supportsPositionedUpdate(); }
998            catch (SQLException e) { handleException(e); return false; } }
999        }
1000    
1001        public boolean supportsResultSetConcurrency(int type, int concurrency)
1002                throws SQLException {
1003            { try { return _meta.supportsResultSetConcurrency(type, concurrency); }
1004            catch (SQLException e) { handleException(e); return false; } }
1005        }
1006    
1007        public boolean supportsResultSetHoldability(int holdability)
1008                throws SQLException {
1009            { try { return _meta.supportsResultSetHoldability(holdability); }
1010            catch (SQLException e) { handleException(e); return false; } }
1011        }
1012    
1013        public boolean supportsResultSetType(int type) throws SQLException {
1014            { try { return _meta.supportsResultSetType(type); }
1015            catch (SQLException e) { handleException(e); return false; } }
1016        }
1017    
1018        public boolean supportsSavepoints() throws SQLException {
1019            { try { return _meta.supportsSavepoints(); }
1020            catch (SQLException e) { handleException(e); return false; } }
1021        }
1022    
1023        public boolean supportsSchemasInDataManipulation() throws SQLException {
1024            { try { return _meta.supportsSchemasInDataManipulation(); }
1025            catch (SQLException e) { handleException(e); return false; } }
1026        }
1027    
1028        public boolean supportsSchemasInIndexDefinitions() throws SQLException {
1029            { try { return _meta.supportsSchemasInIndexDefinitions(); }
1030            catch (SQLException e) { handleException(e); return false; } }
1031        }
1032    
1033        public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
1034            { try { return _meta.supportsSchemasInPrivilegeDefinitions(); }
1035            catch (SQLException e) { handleException(e); return false; } }
1036        }
1037    
1038        public boolean supportsSchemasInProcedureCalls() throws SQLException {
1039            { try { return _meta.supportsSchemasInProcedureCalls(); }
1040            catch (SQLException e) { handleException(e); return false; } }
1041        }
1042    
1043        public boolean supportsSchemasInTableDefinitions() throws SQLException {
1044            { try { return _meta.supportsSchemasInTableDefinitions(); }
1045            catch (SQLException e) { handleException(e); return false; } }
1046        }
1047    
1048        public boolean supportsSelectForUpdate() throws SQLException {
1049            { try { return _meta.supportsSelectForUpdate(); }
1050            catch (SQLException e) { handleException(e); return false; } }
1051        }
1052    
1053        public boolean supportsStatementPooling() throws SQLException {
1054            { try { return _meta.supportsStatementPooling(); }
1055            catch (SQLException e) { handleException(e); return false; } }
1056        }
1057    
1058        public boolean supportsStoredProcedures() throws SQLException {
1059            { try { return _meta.supportsStoredProcedures(); }
1060            catch (SQLException e) { handleException(e); return false; } }
1061        }
1062    
1063        public boolean supportsSubqueriesInComparisons() throws SQLException {
1064            { try { return _meta.supportsSubqueriesInComparisons(); }
1065            catch (SQLException e) { handleException(e); return false; } }
1066        }
1067    
1068        public boolean supportsSubqueriesInExists() throws SQLException {
1069            { try { return _meta.supportsSubqueriesInExists(); }
1070            catch (SQLException e) { handleException(e); return false; } }
1071        }
1072    
1073        public boolean supportsSubqueriesInIns() throws SQLException {
1074            { try { return _meta.supportsSubqueriesInIns(); }
1075            catch (SQLException e) { handleException(e); return false; } }
1076        }
1077    
1078        public boolean supportsSubqueriesInQuantifieds() throws SQLException {
1079            { try { return _meta.supportsSubqueriesInQuantifieds(); }
1080            catch (SQLException e) { handleException(e); return false; } }
1081        }
1082    
1083        public boolean supportsTableCorrelationNames() throws SQLException {
1084            { try { return _meta.supportsTableCorrelationNames(); }
1085            catch (SQLException e) { handleException(e); return false; } }
1086        }
1087    
1088        public boolean supportsTransactionIsolationLevel(int level)
1089                throws SQLException {
1090            { try { return _meta.supportsTransactionIsolationLevel(level); }
1091            catch (SQLException e) { handleException(e); return false; } }
1092        }
1093    
1094        public boolean supportsTransactions() throws SQLException {
1095            { try { return _meta.supportsTransactions(); }
1096            catch (SQLException e) { handleException(e); return false; } }
1097        }
1098    
1099        public boolean supportsUnion() throws SQLException {
1100            { try { return _meta.supportsUnion(); }
1101            catch (SQLException e) { handleException(e); return false; } }
1102        }
1103    
1104        public boolean supportsUnionAll() throws SQLException {
1105            { try { return _meta.supportsUnionAll(); }
1106            catch (SQLException e) { handleException(e); return false; } }
1107        }
1108    
1109        public boolean updatesAreDetected(int type) throws SQLException {
1110            { try { return _meta.updatesAreDetected(type); }
1111            catch (SQLException e) { handleException(e); return false; } }
1112        }
1113    
1114        public boolean usesLocalFilePerTable() throws SQLException {
1115            { try { return _meta.usesLocalFilePerTable(); }
1116            catch (SQLException e) { handleException(e); return false; } }
1117        }
1118    
1119        public boolean usesLocalFiles() throws SQLException {
1120            { try { return _meta.usesLocalFiles(); }
1121            catch (SQLException e) { handleException(e); return false; } }
1122        }
1123    
1124        /*
1125    
1126        public boolean isWrapperFor(Class<?> iface) throws SQLException {
1127            return iface.isAssignableFrom(getClass()) || _meta.isWrapperFor(iface);
1128        }
1129    
1130        public <T> T unwrap(Class<T> iface) throws SQLException {
1131            if (iface.isAssignableFrom(getClass())) {
1132                return iface.cast(this);
1133            } else if (iface.isAssignableFrom(_meta.getClass())) {
1134                return iface.cast(_meta);
1135            } else {
1136                return _meta.unwrap(iface);
1137            }
1138        }
1139        
1140        public RowIdLifetime getRowIdLifetime() throws SQLException {
1141            { try { return _meta.getRowIdLifetime(); }
1142            catch (SQLException e) { handleException(e); throw new AssertionError(); } }
1143        }
1144    
1145        public ResultSet getSchemas(String catalog, String schemaPattern)
1146        throws SQLException {
1147            _conn.checkOpen();
1148            try {
1149                return DelegatingResultSet.wrapResultSet(_conn,
1150                        _meta.getSchemas(catalog, schemaPattern));
1151            }
1152            catch (SQLException e) {
1153                handleException(e);
1154                throw new AssertionError();
1155            }
1156        }
1157    
1158        public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
1159            { try { return _meta.autoCommitFailureClosesAllResultSets(); }
1160            catch (SQLException e) { handleException(e); return false; } }
1161        }
1162    
1163        public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
1164            { try { return _meta.supportsStoredFunctionsUsingCallSyntax(); }
1165            catch (SQLException e) { handleException(e); return false; } }
1166        }
1167    
1168        public ResultSet getClientInfoProperties() throws SQLException {
1169            _conn.checkOpen();
1170            try {
1171                return DelegatingResultSet.wrapResultSet(_conn,
1172                        _meta.getClientInfoProperties());
1173            }
1174            catch (SQLException e) {
1175                handleException(e);
1176                throw new AssertionError();
1177            }
1178        }
1179    
1180        public ResultSet getFunctions(String catalog, String schemaPattern,
1181                String functionNamePattern) throws SQLException {
1182            _conn.checkOpen();
1183            try {
1184                return DelegatingResultSet.wrapResultSet(_conn,
1185                        _meta.getFunctions(catalog, schemaPattern,
1186                                functionNamePattern));
1187            }
1188            catch (SQLException e) {
1189                handleException(e);
1190                throw new AssertionError();
1191            }
1192        }
1193    
1194        public ResultSet getFunctionColumns(String catalog, String schemaPattern,
1195                String functionNamePattern, String columnNamePattern)
1196                throws SQLException {
1197            _conn.checkOpen();
1198            try {
1199                return DelegatingResultSet.wrapResultSet(_conn,
1200                        _meta.getFunctionColumns(catalog, schemaPattern,
1201                                functionNamePattern, columnNamePattern));
1202            }
1203            catch (SQLException e) {
1204                handleException(e);
1205                throw new AssertionError();
1206            }
1207        }
1208    
1209        */
1210    
1211    }