RJDatabaseMetaDataInterface


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  interface RJDatabaseMetaDataInterface extends java.rmi.Remote   {
36  
37    //----------------------------------------------------------------------
38    // First, a variety of minor information about the target database.
39  
40      /**
41       * Can all the procedures returned by getProcedures be called by the
42       * current user?
43       *
44       * @return true if so
45       */
46    boolean allProceduresAreCallable() throws RemoteException  , SQLException;
47  
48      /**
49       * Can all the tables returned by getTable be SELECTed by the
50       * current user?
51       *
52       * @return true if so 
53       */
54    boolean allTablesAreSelectable() throws RemoteException  , SQLException;
55  
56      /**
57       * What's the url for this database?
58       *
59       * @return the url or null if it can't be generated
60       */
61    String   getURL() throws RemoteException  , SQLException;
62  
63      /**
64       * What's our user name as known to the database?
65       *
66       * @return our database user name
67       */
68    String   getUserName() throws RemoteException  , SQLException;
69  
70      /**
71       * Is the database in read-only mode?
72       *
73       * @return true if so
74       */
75    boolean isReadOnly() throws RemoteException  , SQLException;
76  
77      /**
78       * Are NULL values sorted high?
79       *
80       * @return true if so
81       */
82    boolean nullsAreSortedHigh() throws RemoteException  , SQLException;
83  
84      /**
85       * Are NULL values sorted low?
86       *
87       * @return true if so
88       */
89    boolean nullsAreSortedLow() throws RemoteException  , SQLException;
90  
91      /**
92       * Are NULL values sorted at the start regardless of sort order?
93       *
94       * @return true if so 
95       */
96    boolean nullsAreSortedAtStart() throws RemoteException  , SQLException;
97  
98      /**
99       * Are NULL values sorted at the end regardless of sort order?
100      *
101      * @return true if so
102      */
103   boolean nullsAreSortedAtEnd() throws RemoteException  , SQLException;
104 
105     /**
106      * What's the name of this database product?
107      *
108      * @return database product name
109      */
110   String   getDatabaseProductName() throws RemoteException  , SQLException;
111 
112     /**
113      * What's the version of this database product?
114      *
115      * @return database version
116      */
117   String   getDatabaseProductVersion() throws RemoteException  , SQLException;
118 
119     /**
120      * What's the name of this JDBC driver?
121      *
122      * @return JDBC driver name
123      */
124   String   getDriverName() throws RemoteException  , SQLException;
125 
126     /**
127      * What's the version of this JDBC driver?
128      *
129      * @return JDBC driver version
130      */
131   String   getDriverVersion() throws RemoteException  , SQLException;
132 
133     /**
134      * What's this JDBC driver's major version number?
135      *
136      * @return JDBC driver major version
137      */
138   int getDriverMajorVersion() throws RemoteException  , SQLException;
139 
140     /**
141      * What's this JDBC driver's minor version number?
142      *
143      * @return JDBC driver minor version number
144      */
145   int getDriverMinorVersion() throws RemoteException  , SQLException;
146 
147     /**
148      * Does the database store tables in a local file?
149      *
150      * @return true if so
151      */
152   boolean usesLocalFiles() throws RemoteException  , SQLException;
153 
154     /**
155      * Does the database use a file for each table?
156      *
157      * @return true if the database uses a local file for each table
158      */
159   boolean usesLocalFilePerTable() throws RemoteException  , SQLException;
160 
161     /**
162      * Does the database treat mixed case unquoted SQL identifiers as
163      * case sensitive and as a result store them in mixed case?
164      *
165      * A JDBC-Compliant driver will always return false.
166      *
167      * @return true if so 
168      */
169   boolean supportsMixedCaseIdentifiers() throws RemoteException  , SQLException;
170 
171     /**
172      * Does the database treat mixed case unquoted SQL identifiers as
173      * case insensitive and store them in upper case?
174      *
175      * @return true if so 
176      */
177   boolean storesUpperCaseIdentifiers() throws RemoteException  , SQLException;
178 
179     /**
180      * Does the database treat mixed case unquoted SQL identifiers as
181      * case insensitive and store them in lower case?
182      *
183      * @return true if so 
184      */
185   boolean storesLowerCaseIdentifiers() throws RemoteException  , SQLException;
186 
187     /**
188      * Does the database treat mixed case unquoted SQL identifiers as
189      * case insensitive and store them in mixed case?
190      *
191      * @return true if so 
192      */
193   boolean storesMixedCaseIdentifiers() throws RemoteException  , SQLException;
194 
195     /**
196      * Does the database treat mixed case quoted SQL identifiers as
197      * case sensitive and as a result store them in mixed case?
198      *
199      * A JDBC-Compliant driver will always return false.
200      *
201      * @return true if so
202      */
203   boolean supportsMixedCaseQuotedIdentifiers()
204   throws RemoteException  , SQLException;
205 
206     /**
207      * Does the database treat mixed case quoted SQL identifiers as
208      * case insensitive and store them in upper case?
209      *
210      * @return true if so 
211      */
212   boolean storesUpperCaseQuotedIdentifiers()
213   throws RemoteException  , SQLException;
214 
215     /**
216      * Does the database treat mixed case quoted SQL identifiers as
217      * case insensitive and store them in lower case?
218      *
219      * @return true if so 
220      */
221   boolean storesLowerCaseQuotedIdentifiers()
222   throws RemoteException  , SQLException;
223 
224     /**
225      * Does the database treat mixed case quoted SQL identifiers as
226      * case insensitive and store them in mixed case?
227      *
228      * @return true if so 
229      */
230   boolean storesMixedCaseQuotedIdentifiers()
231   throws RemoteException  , SQLException;
232 
233     /**
234      * What's the string used to quote SQL identifiers?
235      * This returns a space " " if identifier quoting isn't supported.
236      *
237      * A JDBC-Compliant driver always uses a double quote character.
238      *
239      * @return the quoting string
240      */
241   String   getIdentifierQuoteString() throws RemoteException  , SQLException;
242 
243     /**
244      * Get a comma separated list of all a database's SQL keywords
245      * that are NOT also SQL92 keywords.
246      *
247      * @return the list 
248      */
249   String   getSQLKeywords() throws RemoteException  , SQLException;
250 
251     /**
252      * Get a comma separated list of math functions.
253      *
254      * @return the list
255      */
256   String   getNumericFunctions() throws RemoteException  , SQLException;
257 
258     /**
259      * Get a comma separated list of string functions.
260      *
261      * @return the list
262      */
263   String   getStringFunctions() throws RemoteException  , SQLException;
264 
265     /**
266      * Get a comma separated list of system functions.
267      *
268      * @return the list
269      */
270   String   getSystemFunctions() throws RemoteException  , SQLException;
271 
272     /**
273      * Get a comma separated list of time and date functions.
274      *
275      * @return the list
276      */
277   String   getTimeDateFunctions() throws RemoteException  , SQLException;
278 
279     /**
280      * This is the string that can be used to escape '_' or '%' in
281      * the string pattern style catalog search parameters.
282      *
283      * <P>The '_' character represents any single character.
284      * <P>The '%' character represents any sequence of zero or 
285      * more characters.
286      * @return the string used to escape wildcard characters
287      */
288   String   getSearchStringEscape() throws RemoteException  , SQLException;
289 
290     /**
291      * Get all the "extra" characters that can be used in unquoted
292      * identifier names (those beyond a-z, A-Z, 0-9 and _).
293      *
294      * @return the string containing the extra characters 
295      */
296   String   getExtraNameCharacters() throws RemoteException  , SQLException;
297 
298     //--------------------------------------------------------------------
299     // Functions describing which features are supported.
300 
301     /**
302      * Is "ALTER TABLE" with add column supported?
303      *
304      * @return true if so
305      */
306   boolean supportsAlterTableWithAddColumn()
307   throws RemoteException  , SQLException;
308 
309     /**
310      * Is "ALTER TABLE" with drop column supported?
311      *
312      * @return true if so
313      */
314   boolean supportsAlterTableWithDropColumn()
315   throws RemoteException  , SQLException;
316 
317     /**
318      * Is column aliasing supported? 
319      *
320      * <P>If so, the SQL AS clause can be used to provide names for
321      * computed columns or to provide alias names for columns as
322      * required.
323      *
324      * A JDBC-Compliant driver always returns true.
325      *
326      * @return true if so 
327      */
328   boolean supportsColumnAliasing() throws RemoteException  , SQLException;
329 
330     /**
331      * Are concatenations between NULL and non-NULL values NULL?
332      *
333      * A JDBC-Compliant driver always returns true.
334      *
335      * @return true if so
336      */
337   boolean nullPlusNonNullIsNull() throws RemoteException  , SQLException;
338 
339     /**
340      * Is the CONVERT function between SQL types supported?
341      *
342      * @return true if so
343      */
344   boolean supportsConvert() throws RemoteException  , SQLException;
345 
346     /**
347      * Is CONVERT between the given SQL types supported?
348      *
349      * @param fromType the type to convert from
350      * @param toType the type to convert to     
351      * @return true if so
352      * @see Types
353      */
354   boolean supportsConvert(int fromType, int toType)
355   throws RemoteException  , SQLException;
356 
357     /**
358      * Are table correlation names supported?
359      *
360      * A JDBC-Compliant driver always returns true.
361      *
362      * @return true if so
363      */
364   boolean supportsTableCorrelationNames() throws RemoteException  , SQLException;
365 
366     /**
367      * If table correlation names are supported, are they restricted
368      * to be different from the names of the tables?
369      *
370      * @return true if so 
371      */
372   boolean supportsDifferentTableCorrelationNames()
373   throws RemoteException  , SQLException;
374 
375     /**
376      * Are expressions in "ORDER BY" lists supported?
377      *
378      * @return true if so
379      */
380   boolean supportsExpressionsInOrderBy() throws RemoteException  , SQLException;
381 
382     /**
383      * Can an "ORDER BY" clause use columns not in the SELECT?
384      *
385      * @return true if so
386      */
387   boolean supportsOrderByUnrelated() throws RemoteException  , SQLException;
388 
389     /**
390      * Is some form of "GROUP BY" clause supported?
391      *
392      * @return true if so
393      */
394   boolean supportsGroupBy() throws RemoteException  , SQLException;
395 
396     /**
397      * Can a "GROUP BY" clause use columns not in the SELECT?
398      *
399      * @return true if so
400      */
401   boolean supportsGroupByUnrelated() throws RemoteException  , SQLException;
402 
403     /**
404      * Can a "GROUP BY" clause add columns not in the SELECT
405      * provided it specifies all the columns in the SELECT?
406      *
407      * @return true if so
408      */
409   boolean supportsGroupByBeyondSelect() throws RemoteException  , SQLException;
410 
411     /**
412      * Is the escape character in "LIKE" clauses supported?
413      *
414      * A JDBC-Compliant driver always returns true.
415      *
416      * @return true if so
417      */
418   boolean supportsLikeEscapeClause() throws RemoteException  , SQLException;
419 
420     /**
421      * Are multiple ResultSets from a single execute supported?
422      *
423      * @return true if so
424      */
425   boolean supportsMultipleResultSets() throws RemoteException  , SQLException;
426 
427     /**
428      * Can we have multiple transactions open at once (on different
429      * connections)?
430      *
431      * @return true if so
432      */
433   boolean supportsMultipleTransactions() throws RemoteException  , SQLException;
434 
435     /**
436      * Can columns be defined as non-nullable?
437      *
438      * A JDBC-Compliant driver always returns true.
439      *
440      * @return true if so
441      */
442   boolean supportsNonNullableColumns() throws RemoteException  , SQLException;
443 
444     /**
445      * Is the ODBC Minimum SQL grammar supported?
446      *
447      * All JDBC-Compliant drivers must return true.
448      *
449      * @return true if so
450      */
451   boolean supportsMinimumSQLGrammar() throws RemoteException  , SQLException;
452 
453     /**
454      * Is the ODBC Core SQL grammar supported?
455      *
456      * @return true if so
457      */
458   boolean supportsCoreSQLGrammar() throws RemoteException  , SQLException;
459 
460     /**
461      * Is the ODBC Extended SQL grammar supported?
462      *
463      * @return true if so
464      */
465   boolean supportsExtendedSQLGrammar() throws RemoteException  , SQLException;
466 
467     /**
468      * Is the ANSI92 entry level SQL grammar supported?
469      *
470      * All JDBC-Compliant drivers must return true.
471      *
472      * @return true if so
473      */
474   boolean supportsANSI92EntryLevelSQL() throws RemoteException  , SQLException;
475 
476     /**
477      * Is the ANSI92 intermediate SQL grammar supported?
478      *
479      * @return true if so
480      */
481   boolean supportsANSI92IntermediateSQL() throws RemoteException  , SQLException;
482 
483     /**
484      * Is the ANSI92 full SQL grammar supported?
485      *
486      * @return true if so
487      */
488   boolean supportsANSI92FullSQL() throws RemoteException  , SQLException;
489 
490     /**
491      * Is the SQL Integrity Enhancement Facility supported?
492      *
493      * @return true if so
494      */
495   boolean supportsIntegrityEnhancementFacility()
496   throws RemoteException  , SQLException;
497 
498     /**
499      * Is some form of outer join supported?
500      *
501      * @return true if so
502      */
503   boolean supportsOuterJoins() throws RemoteException  , SQLException;
504 
505     /**
506      * Are full nested outer joins supported?
507      *
508      * @return true if so
509      */
510   boolean supportsFullOuterJoins() throws RemoteException  , SQLException;
511 
512     /**
513      * Is there limited support for outer joins?  (This will be true
514      * if supportFullOuterJoins is true.)
515      *
516      * @return true if so
517      */
518   boolean supportsLimitedOuterJoins() throws RemoteException  , SQLException;
519 
520     /**
521      * What's the database vendor's preferred term for "schema"?
522      *
523      * @return the vendor term
524      */
525   String   getSchemaTerm() throws RemoteException  , SQLException;
526 
527     /**
528      * What's the database vendor's preferred term for "procedure"?
529      *
530      * @return the vendor term
531      */
532   String   getProcedureTerm() throws RemoteException  , SQLException;
533 
534     /**
535      * What's the database vendor's preferred term for "catalog"?
536      *
537      * @return the vendor term
538      */
539   String   getCatalogTerm() throws RemoteException  , SQLException;
540 
541     /**
542      * Does a catalog appear at the start of a qualified table name?
543      * (Otherwise it appears at the end)
544      *
545      * @return true if it appears at the start 
546      */
547   boolean isCatalogAtStart() throws RemoteException  , SQLException;
548 
549     /**
550      * What's the separator between catalog and table name?
551      *
552      * @return the separator string
553      */
554   String   getCatalogSeparator() throws RemoteException  , SQLException;
555 
556     /**
557      * Can a schema name be used in a data manipulation statement?
558      *
559      * @return true if so
560      */
561   boolean supportsSchemasInDataManipulation()
562   throws RemoteException  , SQLException;
563 
564     /**
565      * Can a schema name be used in a procedure call statement?
566      *
567      * @return true if so
568      */
569   boolean supportsSchemasInProcedureCalls()
570   throws RemoteException  , SQLException;
571 
572     /**
573      * Can a schema name be used in a table definition statement?
574      *
575      * @return true if so
576      */
577   boolean supportsSchemasInTableDefinitions()
578   throws RemoteException  , SQLException;
579 
580     /**
581      * Can a schema name be used in an index definition statement?
582      *
583      * @return true if so
584      */
585   boolean supportsSchemasInIndexDefinitions()
586   throws RemoteException  , SQLException;
587 
588     /**
589      * Can a schema name be used in a privilege definition statement?
590      *
591      * @return true if so
592      */
593   boolean supportsSchemasInPrivilegeDefinitions()
594   throws RemoteException  , SQLException;
595 
596     /**
597      * Can a catalog name be used in a data manipulation statement?
598      *
599      * @return true if so
600      */
601   boolean supportsCatalogsInDataManipulation()
602   throws RemoteException  , SQLException;
603 
604     /**
605      * Can a catalog name be used in a procedure call statement?
606      *
607      * @return true if so
608      */
609   boolean supportsCatalogsInProcedureCalls()
610   throws RemoteException  , SQLException;
611 
612     /**
613      * Can a catalog name be used in a table definition statement?
614      *
615      * @return true if so
616      */
617   boolean supportsCatalogsInTableDefinitions()
618   throws RemoteException  , SQLException;
619 
620     /**
621      * Can a catalog name be used in an index definition statement?
622      *
623      * @return true if so
624      */
625   boolean supportsCatalogsInIndexDefinitions()
626   throws RemoteException  , SQLException;
627 
628     /**
629      * Can a catalog name be used in a privilege definition statement?
630      *
631      * @return true if so
632      */
633   boolean supportsCatalogsInPrivilegeDefinitions()
634   throws RemoteException  , SQLException;
635 
636 
637     /**
638      * Is positioned DELETE supported?
639      *
640      * @return true if so
641      */
642   boolean supportsPositionedDelete() throws RemoteException  , SQLException;
643 
644     /**
645      * Is positioned UPDATE supported?
646      *
647      * @return true if so
648      */
649   boolean supportsPositionedUpdate() throws RemoteException  , SQLException;
650 
651     /**
652      * Is SELECT for UPDATE supported?
653      *
654      * @return true if so
655      */
656   boolean supportsSelectForUpdate() throws RemoteException  , SQLException;
657 
658     /**
659      * Are stored procedure calls using the stored procedure escape
660      * syntax supported?
661      *
662      * @return true if so 
663      */
664   boolean supportsStoredProcedures() throws RemoteException  , SQLException;
665 
666     /**
667      * Are subqueries in comparison expressions supported?
668      *
669      * A JDBC-Compliant driver always returns true.
670      *
671      * @return true if so
672      */
673   boolean supportsSubqueriesInComparisons()
674   throws RemoteException  , SQLException;
675 
676     /**
677      * Are subqueries in 'exists' expressions supported?
678      *
679      * A JDBC-Compliant driver always returns true.
680      *
681      * @return true if so
682      */
683   boolean supportsSubqueriesInExists() throws RemoteException  , SQLException;
684 
685     /**
686      * Are subqueries in 'in' statements supported?
687      *
688      * A JDBC-Compliant driver always returns true.
689      *
690      * @return true if so
691      */
692   boolean supportsSubqueriesInIns() throws RemoteException  , SQLException;
693 
694     /**
695      * Are subqueries in quantified expressions supported?
696      *
697      * A JDBC-Compliant driver always returns true.
698      *
699      * @return true if so
700      */
701   boolean supportsSubqueriesInQuantifieds()
702   throws RemoteException  , SQLException;
703 
704     /**
705      * Are correlated subqueries supported?
706      *
707      * A JDBC-Compliant driver always returns true.
708      *
709      * @return true if so
710      */
711   boolean supportsCorrelatedSubqueries() throws RemoteException  , SQLException;
712 
713     /**
714      * Is SQL UNION supported?
715      *
716      * @return true if so
717      */
718   boolean supportsUnion() throws RemoteException  , SQLException;
719 
720     /**
721      * Is SQL UNION ALL supported?
722      *
723      * @return true if so
724      */
725   boolean supportsUnionAll() throws RemoteException  , SQLException;
726 
727     /**
728      * Can cursors remain open across commits? 
729      * 
730      * @return true if cursors always remain open; false if they might not remain open
731      */
732   boolean supportsOpenCursorsAcrossCommit()
733   throws RemoteException  , SQLException;
734 
735     /**
736      * Can cursors remain open across rollbacks?
737      * 
738      * @return true if cursors always remain open; false if they might not remain open
739      */
740   boolean supportsOpenCursorsAcrossRollback()
741   throws RemoteException  , SQLException;
742 
743     /**
744      * Can statements remain open across commits?
745      * 
746      * @return true if statements always remain open; false if they might not remain open
747      */
748   boolean supportsOpenStatementsAcrossCommit()
749   throws RemoteException  , SQLException;
750 
751     /**
752      * Can statements remain open across rollbacks?
753      * 
754      * @return true if statements always remain open; false if they might not remain open
755      */
756   boolean supportsOpenStatementsAcrossRollback()
757   throws RemoteException  , SQLException;
758 
759   
760 
761     //----------------------------------------------------------------------
762     // The following group of methods exposes various limitations 
763     // based on the target database with the current driver.
764     // Unless otherwise specified, a result of zero means there is no
765     // limit, or the limit is not known.
766   
767     /**
768      * How many hex characters can you have in an inline binary literal?
769      *
770      * @return max literal length
771      */
772   int getMaxBinaryLiteralLength() throws RemoteException  , SQLException;
773 
774     /**
775      * What's the max length for a character literal?
776      *
777      * @return max literal length
778      */
779   int getMaxCharLiteralLength() throws RemoteException  , SQLException;
780 
781     /**
782      * What's the limit on column name length?
783      *
784      * @return max literal length
785      */
786   int getMaxColumnNameLength() throws RemoteException  , SQLException;
787 
788     /**
789      * What's the maximum number of columns in a "GROUP BY" clause?
790      *
791      * @return max number of columns
792      */
793   int getMaxColumnsInGroupBy() throws RemoteException  , SQLException;
794 
795     /**
796      * What's the maximum number of columns allowed in an index?
797      *
798      * @return max columns
799      */
800   int getMaxColumnsInIndex() throws RemoteException  , SQLException;
801 
802     /**
803      * What's the maximum number of columns in an "ORDER BY" clause?
804      *
805      * @return max columns
806      */
807   int getMaxColumnsInOrderBy() throws RemoteException  , SQLException;
808 
809     /**
810      * What's the maximum number of columns in a "SELECT" list?
811      *
812      * @return max columns
813      */
814   int getMaxColumnsInSelect() throws RemoteException  , SQLException;
815 
816     /**
817      * What's the maximum number of columns in a table?
818      *
819      * @return max columns
820      */
821   int getMaxColumnsInTable() throws RemoteException  , SQLException;
822 
823     /**
824      * How many active connections can we have at a time to this database?
825      *
826      * @return max connections
827      */
828   int getMaxConnections() throws RemoteException  , SQLException;
829 
830     /**
831      * What's the maximum cursor name length?
832      *
833      * @return max cursor name length in bytes
834      */
835   int getMaxCursorNameLength() throws RemoteException  , SQLException;
836 
837     /**
838      * What's the maximum length of an index (in bytes)?  
839      *
840      * @return max index length in bytes
841      */
842   int getMaxIndexLength() throws RemoteException  , SQLException;
843 
844     /**
845      * What's the maximum length allowed for a schema name?
846      *
847      * @return max name length in bytes
848      */
849   int getMaxSchemaNameLength() throws RemoteException  , SQLException;
850 
851     /**
852      * What's the maximum length of a procedure name?
853      *
854      * @return max name length in bytes
855      */
856   int getMaxProcedureNameLength() throws RemoteException  , SQLException;
857 
858     /**
859      * What's the maximum length of a catalog name?
860      *
861      * @return max name length in bytes
862      */
863   int getMaxCatalogNameLength() throws RemoteException  , SQLException;
864 
865     /**
866      * What's the maximum length of a single row?
867      *
868      * @return max row size in bytes
869      */
870   int getMaxRowSize() throws RemoteException  , SQLException;
871 
872     /**
873      * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
874      * blobs?
875      *
876      * @return true if so 
877      */
878   boolean doesMaxRowSizeIncludeBlobs() throws RemoteException  , SQLException;
879 
880     /**
881      * What's the maximum length of a SQL statement?
882      *
883      * @return max length in bytes
884      */
885   int getMaxStatementLength() throws RemoteException  , SQLException;
886 
887     /**
888      * How many active statements can we have open at one time to this
889      * database?
890      *
891      * @return the maximum 
892      */
893   int getMaxStatements() throws RemoteException  , SQLException;
894 
895     /**
896      * What's the maximum length of a table name?
897      *
898      * @return max name length in bytes
899      */
900   int getMaxTableNameLength() throws RemoteException  , SQLException;
901 
902     /**
903      * What's the maximum number of tables in a SELECT?
904      *
905      * @return the maximum
906      */
907   int getMaxTablesInSelect() throws RemoteException  , SQLException;
908 
909     /**
910      * What's the maximum length of a user name?
911      *
912      * @return max name length  in bytes
913      */
914   int getMaxUserNameLength() throws RemoteException  , SQLException;
915 
916     //----------------------------------------------------------------------
917 
918     /**
919      * What's the database's default transaction isolation level?  The
920      * values are defined in java.sql.Connection.
921      *
922      * @return the default isolation level 
923      * @see Connection
924      */
925   int getDefaultTransactionIsolation() throws RemoteException  , SQLException;
926 
927     /**
928      * Are transactions supported? If not, commit is a noop and the
929      * isolation level is TRANSACTION_NONE.
930      *
931      * @return true if transactions are supported 
932      */
933   boolean supportsTransactions() throws RemoteException  , SQLException;
934 
935     /**
936      * Does the database support the given transaction isolation level?
937      *
938      * @param level the values are defined in java.sql.Connection
939      * @return true if so 
940      * @see Connection
941      */
942   boolean supportsTransactionIsolationLevel(int level)
943   throws RemoteException  , SQLException;
944 
945     /**
946      * Are both data definition and data manipulation statements
947      * within a transaction supported?
948      *
949      * @return true if so 
950      */
951   boolean supportsDataDefinitionAndDataManipulationTransactions()
952   throws RemoteException  , SQLException;
953 
954     /**
955      * Are only data manipulation statements within a transaction
956      * supported?
957      *
958      * @return true if so
959      */
960   boolean supportsDataManipulationTransactionsOnly()
961   throws RemoteException  , SQLException;
962 
963     /**
964      * Does a data definition statement within a transaction force the
965      * transaction to commit?
966      *
967      * @return true if so 
968      */
969   boolean dataDefinitionCausesTransactionCommit()
970   throws RemoteException  , SQLException;
971 
972     /**
973      * Is a data definition statement within a transaction ignored?
974      *
975      * @return true if so 
976      */
977   boolean dataDefinitionIgnoredInTransactions()
978   throws RemoteException  , SQLException;
979 
980 
981     /**
982      * Get a description of stored procedures available in a
983      * catalog.
984      *
985      * <P>Only procedure descriptions matching the schema and
986      * procedure name criteria are returned.  They are ordered by
987      * PROCEDURE_SCHEM, and PROCEDURE_NAME.
988      *
989      * <P>Each procedure description has the the following columns:
990      *  <OL>
991      *  <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be null)
992      *  <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be null)
993      *  <LI><B>PROCEDURE_NAME</B> String => procedure name
994      *  <LI> reserved for future use
995      *  <LI> reserved for future use
996      *  <LI> reserved for future use
997      *  <LI><B>REMARKS</B> String => explanatory comment on the procedure
998      *  <LI><B>PROCEDURE_TYPE</B> short => kind of procedure:
999      *      <UL>
1000     *      <LI> procedureResultUnknown - May return a result
1001     *      <LI> procedureNoResult - Does not return a result
1002     *      <LI> procedureReturnsResult - Returns a result
1003     *      </UL>
1004     *  </OL>
1005     *
1006     * @param catalog a catalog name; "" retrieves those without a
1007     * catalog; null means drop catalog name from the selection criteria
1008     * @param schemaPattern a schema name pattern; "" retrieves those
1009     * without a schema
1010     * @param procedureNamePattern a procedure name pattern 
1011     * @return RJResultSetInterface - each row is a procedure description 
1012     * @see #getSearchStringEscape 
1013     */
1014  RJResultSetInterface getProcedures(String   catalog, String   schemaPattern,
1015   String   procedureNamePattern) throws RemoteException  , SQLException;
1016
1017    /**
1018     * Get a description of a catalog's stored procedure parameters
1019     * and result columns.
1020     *
1021     * <P>Only descriptions matching the schema, procedure and
1022     * parameter name criteria are returned.  They are ordered by
1023     * PROCEDURE_SCHEM and PROCEDURE_NAME. Within this, the return value,
1024     * if any, is first. Next are the parameter descriptions in call
1025     * order. The column descriptions follow in column number order.
1026     *
1027     * <P>Each row in the RJResultSetInterface is a parameter description or
1028     * column description with the following fields:
1029     *  <OL><