Java > Open Source Codes > org > objectweb > rmijdbc > RJDatabaseMetaData


1
2 /**
3  * RmiJdbc client/server JDBC Driver
4  * (C) GIE Dyade (Groupe BULL / INRIA Research Center) 1997
5  *
6  * @version 1.0
7  * @author Pierre-Yves Gibello (pierreyves.gibello@experlog.com)
8  */
9
10 package org.objectweb.rmijdbc;
11
12 import java.sql.*;
13 import java.rmi.RemoteException ;
14
15 /**
16  * This class provides information about the database as a whole.
17  *
18  * <P>Many of the methods here return lists of information in ResultSets.
19  * You can use the normal ResultSet methods such as getString and getInt
20  * to retrieve the data from these ResultSets. If a given form of
21  * metadata is not available, these methods should throw a SQLException.
22  *
23  * <P>Some of these methods take arguments that are String patterns. These
24  * arguments all have names such as fooPattern. Within a pattern String, "%"
25  * means match any substring of 0 or more characters, and "_" means match
26  * any one character. Only metadata entries matching the search pattern
27  * are returned. If a search pattern argument is set to a null ref, it means
28  * that argument's criteria should be dropped from the search.
29  *
30  * <P>A SQLException will be thrown if a driver does not support a meta
31  * data method. In the case of methods that return a ResultSet,
32  * either a ResultSet (which may be empty) is returned or a
33  * SQLException is thrown.
34  */
35 public class RJDatabaseMetaData
36 implements java.sql.DatabaseMetaData , java.io.Serializable {
37
38   RJDatabaseMetaDataInterface rmiMetadata_;
39   Connection connection_;
40
41   public RJDatabaseMetaData(RJDatabaseMetaDataInterface d, Connection c) {
42     rmiMetadata_ = d;
43     connection_ = c;
44   }
45
46   //----------------------------------------------------------------------
47 // First, a variety of minor information about the target database.
48
49   /**
50    * Can all the procedures returned by getProcedures be called by the
51    * current user?
52    *
53    * @return true if so
54    */
55   public boolean allProceduresAreCallable() throws SQLException {
56     try {
57       return rmiMetadata_.allProceduresAreCallable();
58     } catch(RemoteException e) {
59       throw new java.sql.SQLException (e.getMessage());
60     }
61   }
62
63     /**
64      * Can all the tables returned by getTable be SELECTed by the
65      * current user?
66      *
67      * @return true if so
68      */
69   public boolean allTablesAreSelectable() throws SQLException {
70     try {
71       return rmiMetadata_.allTablesAreSelectable();
72     } catch(RemoteException e) {
73       throw new java.sql.SQLException (e.getMessage());
74     }
75   }
76
77     /**
78      * What's the url for this database?
79      *
80      * @return the url or null if it can't be generated
81      */
82   public String getURL() throws SQLException {
83     try {
84       return rmiMetadata_.getURL();
85     } catch(RemoteException e) {
86       throw new java.sql.SQLException (e.getMessage());
87     }
88   }
89
90     /**
91      * What's our user name as known to the database?
92      *
93      * @return our database user name
94      */
95   public String getUserName() throws SQLException {
96     try {
97       return rmiMetadata_.getUserName();
98     } catch(RemoteException e) {
99       throw new java.sql.SQLException (e.getMessage());
100     }
101   }
102
103     /**
104      * Is the database in read-only mode?
105      *
106      * @return true if so
107      */
108   public boolean isReadOnly() throws SQLException {
109     try {
110       return rmiMetadata_.isReadOnly();
111     } catch(RemoteException e) {
112       throw new java.sql.SQLException (e.getMessage());
113     }
114   }
115
116     /**
117      * Are NULL values sorted high?
118      *
119      * @return true if so
120      */
121   public boolean nullsAreSortedHigh() throws SQLException {
122     try {
123       return rmiMetadata_.nullsAreSortedHigh();
124     } catch(RemoteException e) {
125       throw new java.sql.SQLException (e.getMessage());
126     }
127   }
128
129     /**
130      * Are NULL values sorted low?
131      *
132      * @return true if so
133      */
134   public boolean nullsAreSortedLow() throws SQLException {
135     try {
136       return rmiMetadata_.nullsAreSortedLow();
137     } catch(RemoteException e) {
138       throw new java.sql.SQLException (e.getMessage());
139     }
140   }
141
142     /**
143      * Are NULL values sorted at the start regardless of sort order?
144      *
145      * @return true if so
146      */
147   public boolean nullsAreSortedAtStart() throws SQLException {
148     try {
149       return rmiMetadata_.nullsAreSortedAtStart();
150     } catch(RemoteException e) {
151       throw new java.sql.SQLException (e.getMessage());
152     }
153   }
154
155     /**
156      * Are NULL values sorted at the end regardless of sort order?
157      *
158      * @return true if so
159      */
160   public boolean nullsAreSortedAtEnd() throws SQLException {
161     try {
162       return rmiMetadata_.nullsAreSortedAtEnd();
163     } catch(RemoteException e) {
164       throw new java.sql.SQLException (e.getMessage());
165     }
166   }
167
168     /**
169      * What's the name of this database product?
170      *
171      * @return database product name
172      */
173   public String getDatabaseProductName() throws SQLException {
174     try {
175       return rmiMetadata_.getDatabaseProductName();
176     } catch(RemoteException e) {
177       throw new java.sql.SQLException (e.getMessage());
178     }
179   }
180
181     /**
182      * What's the version of this database product?
183      *
184      * @return database version
185      */
186   public String getDatabaseProductVersion() throws SQLException {
187     try {
188       return rmiMetadata_.getDatabaseProductVersion();
189     } catch(RemoteException e) {
190       throw new java.sql.SQLException (e.getMessage());
191     }
192   }
193
194     /**
195      * What's the name of this JDBC driver?
196      *
197      * @return JDBC driver name
198      */
199   public String getDriverName() throws SQLException {
200     try {
201       return rmiMetadata_.getDriverName();
202     } catch(RemoteException e) {
203       throw new java.sql.SQLException (e.getMessage());
204     }
205   }
206
207     /**
208      * What's the version of this JDBC driver?
209      *
210      * @return JDBC driver version
211      */
212   public String getDriverVersion() throws SQLException {
213     try {
214       return rmiMetadata_.getDriverVersion();
215     } catch(RemoteException e) {
216       throw new java.sql.SQLException (e.getMessage());
217     }
218   }
219
220     /**
221      * What's this JDBC driver's major version number?
222      *
223      * @return JDBC driver major version
224      */
225   public int getDriverMajorVersion() {
226     try {
227       return rmiMetadata_.getDriverMajorVersion();
228     } catch(Exception e) {
229       return 0;
230     }
231   }
232
233     /**
234      * What's this JDBC driver's minor version number?
235      *
236      * @return JDBC driver minor version number
237      */
238   public int getDriverMinorVersion() {
239     try {
240       return rmiMetadata_.getDriverMinorVersion();
241     } catch(Exception e) {
242       return 0;
243     }
244   }
245
246     /**
247      * Does the database store tables in a local file?
248      *
249      * @return true if so
250      */
251   public boolean usesLocalFiles() throws SQLException {
252     try {
253       return rmiMetadata_.usesLocalFiles();
254     } catch(RemoteException e) {
255       throw new java.sql.SQLException (e.getMessage());
256     }
257   }
258
259     /**
260      * Does the database use a file for each table?
261      *
262      * @return true if the database uses a local file for each table
263      */
264   public boolean usesLocalFilePerTable() throws SQLException {
265     try {
266       return rmiMetadata_.usesLocalFilePerTable();
267     } catch(RemoteException e) {
268       throw new java.sql.SQLException (e.getMessage());
269     }
270   }
271
272     /**
273      * Does the database treat mixed case unquoted SQL identifiers as
274      * case sensitive and as a result store them in mixed case?
275      *
276      * A JDBC-Compliant driver will always return false.
277      *
278      * @return true if so
279      */
280   public boolean supportsMixedCaseIdentifiers() throws SQLException {
281     try {
282       return rmiMetadata_.supportsMixedCaseIdentifiers();
283     } catch(RemoteException e) {
284       throw new java.sql.SQLException (e.getMessage());
285     }
286   }
287
288     /**
289      * Does the database treat mixed case unquoted SQL identifiers as
290      * case insensitive and store them in upper case?
291      *
292      * @return true if so
293      */
294   public boolean storesUpperCaseIdentifiers() throws SQLException {
295     try {
296       return rmiMetadata_.storesUpperCaseIdentifiers();
297     } catch(RemoteException e) {
298       throw new java.sql.SQLException (e.getMessage());
299     }
300   }
301
302     /**
303      * Does the database treat mixed case unquoted SQL identifiers as
304      * case insensitive and store them in lower case?
305      *
306      * @return true if so
307      */
308   public boolean storesLowerCaseIdentifiers() throws SQLException {
309     try {
310       return rmiMetadata_.storesLowerCaseIdentifiers();
311     } catch(RemoteException e) {
312       throw new java.sql.SQLException (e.getMessage());
313     }
314   }
315
316     /**
317      * Does the database treat mixed case unquoted SQL identifiers as
318      * case insensitive and store them in mixed case?
319      *
320      * @return true if so
321      */
322   public boolean storesMixedCaseIdentifiers() throws SQLException {
323     try {
324       return rmiMetadata_.storesMixedCaseIdentifiers();
325     } catch(RemoteException e) {
326       throw new java.sql.SQLException (e.getMessage());
327     }
328   }
329
330     /**
331      * Does the database treat mixed case quoted SQL identifiers as
332      * case sensitive and as a result store them in mixed case?
333      *
334      * A JDBC-Compliant driver will always return false.
335      *
336      * @return true if so
337      */
338   public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
339     try {
340       return rmiMetadata_.supportsMixedCaseQuotedIdentifiers();
341     } catch(RemoteException e) {
342       throw new java.sql.SQLException (e.getMessage());
343     }
344   }
345
346     /**
347      * Does the database treat mixed case quoted SQL identifiers as
348      * case insensitive and store them in upper case?
349      *
350      * @return true if so
351      */
352   public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
353     try {
354       return rmiMetadata_.storesUpperCaseQuotedIdentifiers();
355     } catch(RemoteException e) {
356       throw new java.sql.SQLException (e.getMessage());
357     }
358   }
359
360     /**
361      * Does the database treat mixed case quoted SQL identifiers as
362      * case insensitive and store them in lower case?
363      *
364      * @return true if so
365      */
366   public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
367     try {
368       return rmiMetadata_.storesLowerCaseQuotedIdentifiers();
369     } catch(RemoteException e) {
370       throw new java.sql.SQLException (e.getMessage());
371     }
372   }
373
374     /**
375      * Does the database treat mixed case quoted SQL identifiers as
376      * case insensitive and store them in mixed case?
377      *
378      * @return true if so
379      */
380   public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
381     try {
382       return rmiMetadata_.storesMixedCaseQuotedIdentifiers();
383     } catch(RemoteException e) {
384       throw new java.sql.SQLException (e.getMessage());
385     }
386   }
387
388     /**
389      * What's the string used to quote SQL identifiers?
390      * This returns a space " " if identifier quoting isn't supported.
391      *
392      * A JDBC-Compliant driver always uses a double quote character.
393      *
394      * @return the quoting string
395      */
396   public String getIdentifierQuoteString() throws SQLException {
397     try {
398       return rmiMetadata_.getIdentifierQuoteString();
399     } catch(RemoteException e) {
400       throw new java.sql.SQLException (e.getMessage());
401     }
402   }
403
404     /**
405      * Get a comma separated list of all a database's SQL keywords
406      * that are NOT also SQL92 keywords.
407      *
408      * @return the list
409      */
410   public String getSQLKeywords() throws SQLException {
411     try {
412       return rmiMetadata_.getSQLKeywords();
413     } catch(RemoteException e) {
414       throw new java.sql.SQLException (e.getMessage());
415     }
416   }
417
418     /**
419      * Get a comma separated list of math functions.
420      *
421      * @return the list
422      */
423   public String getNumericFunctions() throws SQLException {
424     try {
425       return rmiMetadata_.getNumericFunctions();
426     } catch(RemoteException e) {
427       throw new java.sql.SQLException (e.getMessage());
428     }
429   }
430
431     /**
432      * Get a comma separated list of string functions.
433      *
434      * @return the list
435      */
436   public String getStringFunctions() throws SQLException {
437     try {
438       return rmiMetadata_.getStringFunctions();
439     } catch(RemoteException e) {
440       throw new java.sql.SQLException (e.getMessage());
441     }
442   }
443
444     /**
445      * Get a comma separated list of system functions.
446      *
447      * @return the list
448      */
449   public String getSystemFunctions() throws SQLException {
450     try {
451       return rmiMetadata_.getSystemFunctions();
452     } catch(RemoteException e) {
453       throw new java.sql.SQLException (e.getMessage());
454     }
455   }
456
457     /**
458      * Get a comma separated list of time and date functions.
459      *
460      * @return the list
461      */
462   public String getTimeDateFunctions() throws SQLException {
463     try {
464       return rmiMetadata_.getTimeDateFunctions();
465     } catch(RemoteException e) {
466       throw new java.sql.SQLException (e.getMessage());
467     }
468   }
469
470     /**
471      * This is the string that can be used to escape '_' or '%' in
472      * the string pattern style catalog search parameters.
473      *
474      * <P>The '_' character represents any single character.
475      * <P>The '%' character represents any sequence of zero or
476      * more characters.
477      * @return the string used to escape wildcard characters
478      */
479   public String getSearchStringEscape() throws SQLException {
480     try {
481       return rmiMetadata_.getSearchStringEscape();
482     } catch(RemoteException e) {
483       throw new java.sql.SQLException (e.getMessage());
484     }
485   }
486
487     /**
488      * Get all the "extra" characters that can be used in unquoted
489      * identifier names (those beyond a-z, A-Z, 0-9 and _).
490      *
491      * @return the string containing the extra characters
492      */
493   public String getExtraNameCharacters() throws SQLException {
494     try {
495       return rmiMetadata_.getExtraNameCharacters();
496     } catch(RemoteException e) {
497       throw new java.sql.SQLException (e.getMessage());
498     }
499   }
500
501     //--------------------------------------------------------------------
502 // Functions describing which features are supported.
503
504     /**
505      * Is "ALTER TABLE" with add column supported?
506      *
507      * @return true if so
508      */
509   public boolean supportsAlterTableWithAddColumn() throws SQLException {
510     try {
511       return rmiMetadata_.supportsAlterTableWithAddColumn();
512     } catch(RemoteException e) {
513       throw new java.sql.SQLException (e.getMessage());
514     }
515   }
516
517     /**
518      * Is "ALTER TABLE" with drop column supported?
519      *
520      * @return true if so
521      */
522   public boolean supportsAlterTableWithDropColumn() throws SQLException {
523     try {
524       return rmiMetadata_.supportsAlterTableWithDropColumn();
525     } catch(RemoteException e) {
526       throw new java.sql.SQLException (e.getMessage());
527     }
528   }
529
530     /**
531      * Is column aliasing supported?
532      *
533      * <P>If so, the SQL AS clause can be used to provide names for
534      * computed columns or to provide alias names for columns as
535      * required.
536      *
537      * A JDBC-Compliant driver always returns true.
538      *
539      * @return true if so
540      */
541   public boolean supportsColumnAliasing() throws SQLException {
542     try {
543       return rmiMetadata_.supportsColumnAliasing();
544     } catch(RemoteException e) {
545       throw new java.sql.SQLException (e.getMessage());
546     }
547   }
548
549     /**
550      * Are concatenations between NULL and non-NULL values NULL?
551      *
552      * A JDBC-Compliant driver always returns true.
553      *
554      * @return true if so
555      */
556   public boolean nullPlusNonNullIsNull() throws SQLException {
557     try {
558       return rmiMetadata_.nullPlusNonNullIsNull();
559     } catch(RemoteException e) {
560       throw new java.sql.SQLException (e.getMessage());
561     }
562   }
563
564     /**
565      * Is the CONVERT function between SQL types supported?
566      *
567      * @return true if so
568      */
569   public boolean supportsConvert() throws SQLException {
570     try {
571       return rmiMetadata_.supportsConvert();
572     } catch(RemoteException e) {
573       throw new java.sql.SQLException (e.getMessage());
574     }
575   }
576
577     /**
578      * Is CONVERT between the given SQL types supported?
579      *
580      * @param fromType the type to convert from
581      * @param toType the type to convert to
582      * @return true if so
583      * @see Types
584      */
585   public boolean supportsConvert(int fromType, int toType) throws SQLException {
586     try {
587       return rmiMetadata_.supportsConvert();
588     } catch(RemoteException e) {
589       throw new java.sql.SQLException (e.getMessage());
590     }
591   }
592
593     /**
594      * Are table correlation names supported?
595      *
596      * A JDBC-Compliant driver always returns true.
597      *
598      * @return true if so
599      */
600   public boolean supportsTableCorrelationNames() throws SQLException {
601     try {
602       return rmiMetadata_.supportsTableCorrelationNames();
603     } catch(RemoteException e) {
604       throw new java.sql.SQLException (e.getMessage());
605     }
606   }
607
608     /**
609      * If table correlation names are supported, are they restricted
610      * to be different from the names of the tables?
611      *
612      * @return true if so
613      */
614   public boolean supportsDifferentTableCorrelationNames() throws SQLException {
615     try {
616       return rmiMetadata_.supportsDifferentTableCorrelationNames();
617     } catch(RemoteException e) {
618       throw new java.sql.SQLException (e.getMessage());
619     }
620   }
621
622     /**
623      * Are expressions in "ORDER BY" lists supported?
624      *
625      * @return true if so
626      */
627   public boolean supportsExpressionsInOrderBy() throws SQLException {
628     try {
629       return rmiMetadata_.supportsExpressionsInOrderBy();
630     } catch(RemoteException e) {
631       throw new java.sql.SQLException (e.getMessage());
632     }
633   }
634
635     /**
636      * Can an "ORDER BY" clause use columns not in the SELECT?
637      *
638      * @return true if so
639      */
640   public boolean supportsOrderByUnrelated() throws SQLException {
641     try {
642       return rmiMetadata_.supportsOrderByUnrelated();
643     } catch(RemoteException e) {
644       throw new java.sql.SQLException (e.getMessage());
645     }
646   }
647
648     /**
649      * Is some form of "GROUP BY" clause supported?
650      *
651      * @return true if so
652      */
653   public boolean supportsGroupBy() throws SQLException {
654     try {
655       return rmiMetadata_.supportsGroupBy();
656     } catch(RemoteException e) {
657       throw new java.sql.SQLException (e.getMessage());
658     }
659   }
660
661     /**
662      * Can a "GROUP BY" clause use columns not in the SELECT?
663      *
664      * @return true if so
665      */
666   public boolean supportsGroupByUnrelated() throws SQLException {
667     try {
668       return rmiMetadata_.supportsGroupByUnrelated();
669     } catch(RemoteException e) {
670       throw new java.sql.SQLException (e.getMessage());
671     }
672   }
673
674     /**
675      * Can a "GROUP BY" clause add columns not in the SELECT
676      * provided it specifies all the columns in the SELECT?
677      *
678      * @return true if so
679      */
680   public boolean supportsGroupByBeyondSelect() throws SQLException {
681     try {
682       return rmiMetadata_.supportsGroupByBeyondSelect();
683     } catch(RemoteException e) {
684       throw new java.sql.SQLException (e.getMessage());
685     }
686   }
687
688     /**
689      * Is the escape character in "LIKE" clauses supported?
690      *
691      * A JDBC-Compliant driver always returns true.
692      *
693      * @return true if so
694      */
695   public boolean supportsLikeEscapeClause() throws SQLException {
696     try {
697       return rmiMetadata_.supportsLikeEscapeClause();
698     } catch(RemoteException e) {
699       throw new java.sql.SQLException (e.getMessage());
700     }
701   }
702
703     /**
704      * Are multiple ResultSets from a single execute supported?
705      *
706      * @return true if so
707      */
708   public boolean supportsMultipleResultSets() throws SQLException {
709     try {
710       return rmiMetadata_.supportsMultipleResultSets();
711     } catch(RemoteException e) {
712       throw new java.sql.SQLException (e.getMessage());
713     }
714   }
715
716     /**
717      * Can we have multiple transactions open at once (on different
718      * connections)?
719      *
720      * @return true if so
721      */
722   public boolean supportsMultipleTransactions() throws SQLException {
723     try {
724       return rmiMetadata_.supportsMultipleTransactions();
725     } catch(RemoteException e) {
726       throw new java.sql.SQLException (e.getMessage());
727     }
728   }
729
730     /**
731      * Can columns be defined as non-nullable?
732      *
733      * A JDBC-Compliant driver always returns true.
734      *
735      * @return true if so
736      */
737   public boolean supportsNonNullableColumns() throws SQLException {
738     try {
739       return rmiMetadata_.supportsNonNullableColumns();
740     } catch(RemoteException e) {
741       throw new java.sql.SQLException (e.getMessage());
742     }
743   }
744
745     /**
746      * Is the ODBC Minimum SQL grammar supported?
747      *
748      * All JDBC-Compliant drivers must return true.
749      *
750      * @return true if so
751      */
752   public boolean supportsMinimumSQLGrammar() throws SQLException {
753     try {
754       return rmiMetadata_.supportsMinimumSQLGrammar();
755     } catch(RemoteException e) {
756       throw new java.sql.SQLException (e.getMessage());
757     }
758   }
759
760     /**
761      * Is the ODBC Core SQL grammar supported?
762      *
763      * @return true if so
764      */
765   public boolean supportsCoreSQLGrammar() throws SQLException {
766     try {
767       return rmiMetadata_.supportsCoreSQLGrammar();
768     } catch(RemoteException e) {
769       throw new java.sql.SQLException (e.getMessage());
770     }
771   }
772
773     /**
774      * Is the ODBC Extended SQL grammar supported?
775      *
776      * @return true if so
777      */
778   public boolean supportsExtendedSQLGrammar() throws SQLException {
779     try {
780       return rmiMetadata_.supportsExtendedSQLGrammar();
781     } catch(RemoteException e) {
782       throw new java.sql.SQLException (e.getMessage());
783     }
784   }
785
786     /**
787      * Is the ANSI92 entry level SQL grammar supported?
788      *
789      * All JDBC-Compliant drivers must return true.
790      *
791      * @return true if so
792      */
793   public boolean supportsANSI92EntryLevelSQL() throws SQLException {
794     try {
795       return rmiMetadata_.supportsANSI92EntryLevelSQL();
796     } catch(RemoteException e) {
797       throw new java.sql.SQLException (e.getMessage());
798     }
799   }
800
801     /**
802      * Is the ANSI92 intermediate SQL grammar supported?
803      *
804      * @return true if so
805      */
806   public boolean supportsANSI92IntermediateSQL() throws SQLException {
807     try {
808       return rmiMetadata_.supportsANSI92IntermediateSQL();
809     } catch(RemoteException e) {
810       throw new java.sql.SQLException (e.getMessage());
811     }
812   }
813
814     /**
815      * Is the ANSI92 full SQL grammar supported?
816      *
817      * @return true if so
818      */
819   public boolean supportsANSI92FullSQL() throws SQLException {
820     try {
821       return rmiMetadata_.supportsANSI92FullSQL();
822     } catch(RemoteException e) {
823       throw new java.sql.SQLException (e.getMessage());
824     }
825   }
826
827     /**
828      * Is the SQL Integrity Enhancement Facility supported?
829      *
830      * @return true if so
831      */
832   public boolean supportsIntegrityEnhancementFacility() throws SQLException {
833     try {
834       return rmiMetadata_.supportsIntegrityEnhancementFacility();
835     } catch(RemoteException e) {
836       throw new java.sql.SQLException (e.getMessage());
837     }
838   }
839
840     /**
841      * Is some form of outer join supported?
842      *
843      * @return true if so
844      */
845   public boolean supportsOuterJoins() throws SQLException {
846     try {
847       return rmiMetadata_.supportsOuterJoins();
848     } catch(RemoteException e) {
849       throw new java.sql.SQLException (e.getMessage());
850     }
851   }
852
853     /**
854      * Are full nested outer joins supported?
855      *
856      * @return true if so
857      */
858   public boolean supportsFullOuterJoins() throws SQLException {
859     try {
860       return rmiMetadata_.supportsFullOuterJoins();
861     } catch(RemoteException e) {
862       throw new java.sql.SQLException (e.getMessage());
863     }
864   }
865
866     /**
867      * Is there limited support for outer joins? (This will be true
868      * if supportFullOuterJoins is true.)
869      *
870      * @return true if so
871      */
872   public boolean supportsLimitedOuterJoins() throws SQLException {
873     try {
874       return rmiMetadata_.supportsLimitedOuterJoins();
875     } catch(RemoteException e) {
876       throw new java.sql.SQLException (e.getMessage());
877     }
878   }
879
880     /**
881      * What's the database vendor's preferred term for "schema"?
882      *
883      * @return the vendor term
884      */
885   public String getSchemaTerm() throws SQLException {
886     try {
887       return rmiMetadata_.getSchemaTerm();
888     } catch(RemoteException e) {
889       throw new java.sql.SQLException (e.getMessage());
890     }
891   }
892
893     /**
894      * What's the database vendor's preferred term for "procedure"?
895      *
896      * @return the vendor term
897      */
898   public String getProcedureTerm() throws SQLException {
899     try {
900       return rmiMetadata_.getProcedureTerm();
901     } catch(RemoteException e) {
902       throw new java.sql.SQLException (e.getMessage());
903     }
904   }
905
906     /**
907      * What's the database vendor's preferred term for "catalog"?
908      *
909      * @return the vendor term
910      */
911   public String getCatalogTerm() throws SQLException {
912     try {
913       return rmiMetadata_.getCatalogTerm();
914     } catch(RemoteException e) {
915       throw new java.sql.SQLException (e.getMessage());
916     }
917   }
918
919     /**
920      * Does a catalog appear at the start of a qualified table name?
921      * (Otherwise it appears at the end)
922      *
923      * @return true if it appears at the start
924      */
925   public boolean isCatalogAtStart() throws SQLException {
926     try {
927       return rmiMetadata_.isCatalogAtStart();
928     } catch(RemoteException e) {
929       throw new java.sql.SQLException (e.getMessage());
930     }
931   }
932
933     /**
934      * What's the separator between catalog and table name?
935      *
936      * @return the separator string
937      */
938   public String getCatalogSeparator() throws SQLException {
939     try {
940       return rmiMetadata_.getCatalogSeparator();
941     } catch(RemoteException e) {
942       throw new java.sql.SQLException (e.getMessage());
943     }
944   }
945
946     /**
947      * Can a schema name be used in a data manipulation statement?
948      *
949      * @return true if so
950      */
951   public boolean supportsSchemasInDataManipulation() throws SQLException {
952     try {
953       return rmiMetadata_.supportsSchemasInDataManipulation();
954     } catch(RemoteException e) {
955       throw new java.sql.SQLException (e.getMessage());
956     }
957   }
958
959     /**
960      * Can a schema name be used in a procedure call statement?
961      *
962      * @return true if so
963      */
964   public boolean supportsSchemasInProcedureCalls() throws SQLException {
965     try {
966       return rmiMetadata_.supportsSchemasInProcedureCalls();