1/**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements.  See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership.  The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License.  You may obtain a copy of the License at
10 *
11 *   http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied.  See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23#ifndef __com_sun_star_sdbc_XDatabaseMetaData_idl__
24#define __com_sun_star_sdbc_XDatabaseMetaData_idl__
25
26#ifndef __com_sun_star_uno_XInterface_idl__
27#include <com/sun/star/uno/XInterface.idl>
28#endif
29
30#ifndef __com_sun_star_sdbc_SQLException_idl__
31#include <com/sun/star/sdbc/SQLException.idl>
32#endif
33
34
35 module com {  module sun {  module star {  module sdbc {
36
37 published interface XResultSet;
38 published interface XConnection;
39
40/** provides comprehensive information about the database as a whole.
41
42
43	<p>Many of the methods here return lists of information in
44	the form of
45	<type scope="com::sun::star::sdbc">XResultSet</type>
46	objects.
47	You can use the normal <type scope="com::sun::star::sdbc">XResultSet</type>
48	methods such as
49	<member scope="com::sun::star::sdbc">XResultSet::getString()</member>
50	and
51	<member scope="com::sun::star::sdbc">XResultSet::getInt()</member>
52	to retrieve the data from these XResultSets. If a given form of
53	metadata is not available, these methods should throw a
54	<type scope="com::sun::star::sdbc">SQLException</type>
55	.
56    That a value of <type scope="com::sun::star::sdbc">XResultSet</type> is <NULL/>
57    can be chaked with the method <member scope="com::sun::star::sdbc">XResultSet::wasNull()</member>.
58    In the text only "(may be <NULL/>)" is mentioned for this case.
59	</p>
60	<p>Some of these methods take arguments that are String patterns. These
61	arguments all have names such as fooPattern. Within a pattern String, "%"
62	means match any substring of 0 or more characters, and "_" means match
63	any one character. Only metadata entries matching the search pattern
64	are returned. If a search pattern argument is set to <VOID/>,
65	that argument's criteria will be dropped from the search.
66	</p>
67	<p>
68	A
69	<type scope="com::sun::star::sdbc">SQLException</type>
70	will be thrown if a driver does not support
71	a meta data method. In the case of methods that return an XResultSet,
72	either an XResultSet (which may be empty) is returned or a
73	SQLException is thrown.</p>
74 */
75published interface XDatabaseMetaData: com::sun::star::uno::XInterface
76{
77
78	/** Can all the procedures returned by getProcedures be called by the
79		current user?
80
81		@return
82		<TRUE/>
83		if the user is allowed to call all procedures returned by getProcedures
84		otherwise
85		<FALSE/>
86		.
87		@throws SQLException
88			if a database access error occurs.
89	 */
90	boolean allProceduresAreCallable() raises (SQLException);
91	//-------------------------------------------------------------------------
92
93	/** Can all the tables returned by getTable be SELECTed by the
94		current user?
95		@returns
96			<TRUE/> if so
97		@throws SQLException
98			if a database access error occurs.
99	 */
100	boolean allTablesAreSelectable() raises (SQLException);
101	//-------------------------------------------------------------------------
102
103	/** returns the URL for the database connection
104	 */
105	string getURL() raises (SQLException);
106	//-------------------------------------------------------------------------
107
108	/** returns the user name from this database connection.
109	 */
110	string getUserName() raises (SQLException);
111	//-------------------------------------------------------------------------
112
113	/** checks if the database in read-only mode.
114		@returns
115			<TRUE/> if so
116		@throws SQLException
117			if a database access error occurs.
118	 */
119	boolean isReadOnly() raises (SQLException);
120	//-------------------------------------------------------------------------
121
122	/** Are NULL values sorted high?
123		@returns
124			<TRUE/> if so
125		@throws SQLException
126			if a database access error occurs.
127	*/
128	boolean nullsAreSortedHigh() raises (SQLException);
129	//-------------------------------------------------------------------------
130
131	/** Are NULL values sorted low?
132		@returns
133			<TRUE/> if so
134		@throws SQLException
135			if a database access error occurs.
136	*/
137	boolean nullsAreSortedLow() raises (SQLException);
138	//-------------------------------------------------------------------------
139
140	/** Are NULL values sorted at the start regardless of sort order?
141		@returns
142			<TRUE/> if so
143		@throws SQLException
144			if a database access error occurs.
145	 */
146	boolean nullsAreSortedAtStart() raises (SQLException);
147	//-------------------------------------------------------------------------
148
149	/**	 Are NULL values sorted at the end, regardless of sort order?
150		@returns
151			<TRUE/> if so
152		@throws SQLException
153			if a database access error occurs.
154	 */
155	boolean nullsAreSortedAtEnd() raises (SQLException);
156	//-------------------------------------------------------------------------
157
158	/** returns the name of the database product.
159	 */
160	string getDatabaseProductName() raises (SQLException);
161	//-------------------------------------------------------------------------
162
163	/** returns the version of the database product.
164	 */
165	string getDatabaseProductVersion() raises (SQLException);
166	//-------------------------------------------------------------------------
167
168	/** returns the name of the SDBC driver.
169	 */
170	string getDriverName() raises (SQLException);
171	//-------------------------------------------------------------------------
172
173	/** returns the version number of the SDBC driver.
174	 */
175	string getDriverVersion() raises (SQLException);
176	//-------------------------------------------------------------------------
177
178	/** returns the SDBC driver major version number.
179	 */
180	long getDriverMajorVersion();
181    //-------------------------------------------------------------------------
182
183	/** returns the SDBC driver minor version number.
184	 */
185	long getDriverMinorVersion();
186	//-------------------------------------------------------------------------
187
188	/** use the database local files to save the tables.
189		@returns
190			<TRUE/> if so
191		@throws SQLException
192			if a database access error occurs.
193	 */
194	boolean usesLocalFiles() raises (SQLException);
195    //-------------------------------------------------------------------------
196
197	/** use the database one local file to save for each table.
198		@returns
199			<TRUE/> if so
200		@throws SQLException
201			if a database access error occurs.
202	 */
203	boolean usesLocalFilePerTable() raises (SQLException);
204	//-------------------------------------------------------------------------
205
206	/** use the database 'mixed case unquoted SQL identifiers' case sensitive.
207		@returns
208			<TRUE/> if so
209		@throws SQLException
210			if a database access error occurs.
211	 */
212	boolean supportsMixedCaseIdentifiers() raises (SQLException);
213	//-------------------------------------------------------------------------
214
215	/** Does the database treat mixed case unquoted SQL identifiers as
216		case insensitive and store them in upper case?
217			@returns
218			<TRUE/> if so
219		@throws SQLException
220			if a database access error occurs.
221	 */
222	boolean storesUpperCaseIdentifiers() raises (SQLException);
223	//-------------------------------------------------------------------------
224
225	/** Does the database treat mixed case unquoted SQL identifiers as
226		case insensitive and store them in lower case?
227		@returns
228			<TRUE/> if so
229		@throws SQLException
230			if a database access error occurs.
231	 */
232	boolean storesLowerCaseIdentifiers() raises (SQLException);
233	//-------------------------------------------------------------------------
234
235	/** Does the database treat mixed case unquoted SQL identifiers as
236		case insensitive and store them in mixed case?
237		@returns
238			<TRUE/> if so
239		@throws SQLException
240			if a database access error occurs.
241	 */
242	boolean storesMixedCaseIdentifiers() raises (SQLException);
243	//-------------------------------------------------------------------------
244
245	/** Does the database treat mixed case quoted SQL identifiers as
246		case sensitive and as a result store them in mixed case?
247		@returns
248			<TRUE/> if so
249		@throws SQLException
250			if a database access error occurs.
251	 */
252	boolean supportsMixedCaseQuotedIdentifiers() raises (SQLException);
253	//-------------------------------------------------------------------------
254
255	/** Does the database treat mixed case quoted SQL identifiers as
256		case insensitive and store them in upper case?
257		@returns
258			<TRUE/> if so
259		@throws SQLException
260			if a database access error occurs.
261	 */
262	boolean storesUpperCaseQuotedIdentifiers() raises (SQLException);
263	//-------------------------------------------------------------------------
264
265	/** Does the database treat mixed case quoted SQL identifiers as
266		case insensitive and store them in lower case?
267		@returns
268			<TRUE/> if so
269		@throws SQLException
270			if a database access error occurs.
271	 */
272	boolean storesLowerCaseQuotedIdentifiers() raises (SQLException);
273	//-------------------------------------------------------------------------
274
275	/** Does the database treat mixed case quoted SQL identifiers as
276		case insensitive and store them in mixed case?
277		@returns
278			<TRUE/> if so
279		@throws SQLException
280			if a database access error occurs.
281	 */
282	boolean storesMixedCaseQuotedIdentifiers() raises (SQLException);
283	//-------------------------------------------------------------------------
284
285	/** What's the string used to quote SQL identifiers?
286		This returns a space " " if identifier quoting is not supported.
287		@returns
288			<TRUE/> if so
289		@throws SQLException
290			if a database access error occurs.
291	 */
292	string getIdentifierQuoteString() raises (SQLException);
293	//-------------------------------------------------------------------------
294
295	/** gets a comma-separated list of all a database's SQL keywords
296		that are NOT also SQL92 keywords.
297		@returns
298			<TRUE/> if so
299		@throws SQLException
300			if a database access error occurs.
301	 */
302	string getSQLKeywords() raises (SQLException);
303	//-------------------------------------------------------------------------
304
305	/** gets a comma-separated list of math functions. These are the
306		X/Open CLI math function names used in the SDBC function escape
307		clause.
308		@returns
309			<TRUE/> if so
310		@throws SQLException
311			if a database access error occurs.
312	 */
313	string getNumericFunctions() raises (SQLException);
314	//-------------------------------------------------------------------------
315
316	/** gets a comma-separated list of string functions. These are the
317		X/Open CLI string function names used in the SDBC function escape
318		clause.
319		@returns
320			<TRUE/> if so
321		@throws SQLException
322			if a database access error occurs.
323	 */
324	string getStringFunctions() raises (SQLException);
325	//-------------------------------------------------------------------------
326
327	/** gets a comma-separated list of system functions. These are the
328		X/Open CLI system function names used in the SDBC function escape
329		clause.
330		@returns
331			<TRUE/> if so
332		@throws SQLException
333			if a database access error occurs.
334	 */
335	string getSystemFunctions() raises (SQLException);
336	//-------------------------------------------------------------------------
337
338	/** gets a comma-separated list of time and date functions.
339		@returns
340			<TRUE/> if so
341		@throws SQLException
342			if a database access error occurs.
343	 */
344	string getTimeDateFunctions() raises (SQLException);
345	//-------------------------------------------------------------------------
346
347	/** gets the string that can be used to escape wildcard characters.
348		This is the string that can be used to escape '_' or '%' in
349		the string pattern style catalog search parameters.
350
351
352		<p>
353		The '_' character represents any single character.
354		</p>
355		<p>
356		The '%' character represents any sequence of zero or
357		more characters.
358		</p>
359		@returns
360			<TRUE/> if so
361		@throws SQLException
362			if a database access error occurs.
363	 */
364	string getSearchStringEscape() raises (SQLException);
365	//-------------------------------------------------------------------------
366
367	/** gets all the "extra" characters that can be used in unquoted
368		identifier names (those beyond a-z, A-Z, 0-9 and _).
369		@returns
370			<TRUE/> if so
371		@throws SQLException
372			if a database access error occurs.
373	 */
374	string getExtraNameCharacters() raises (SQLException);
375    //-------------------------------------------------------------------------
376
377	/** support the Database "ALTER TABLE" with add column?
378		@returns
379			<TRUE/> if so
380		@throws SQLException
381			if a database access error occurs.
382	 */
383	boolean supportsAlterTableWithAddColumn() raises (SQLException);
384    //-------------------------------------------------------------------------
385
386	/** support the Database  "ALTER TABLE" with drop column?
387		@returns
388			<TRUE/> if so
389		@throws SQLException
390			if a database access error occurs.
391	 */
392	boolean supportsAlterTableWithDropColumn() raises (SQLException);
393	//-------------------------------------------------------------------------
394
395	/** support the Database column aliasing?
396
397
398		<p>
399		The SQL AS clause can be used to provide names for
400		computed columns or to provide alias names for columns as required.
401		</p>
402		@returns
403			<TRUE/> if so
404		@throws SQLException
405			if a database access error occurs.
406	 */
407	boolean supportsColumnAliasing() raises (SQLException);
408    //-------------------------------------------------------------------------
409
410	/** are concatenations between NULL and non-NULL values NULL?
411		@returns
412			<TRUE/> if so
413		@throws SQLException
414			if a database access error occurs.
415	 */
416	boolean nullPlusNonNullIsNull() raises (SQLException);
417	//-------------------------------------------------------------------------
418
419	/** <TRUE/>
420			, if the Database supports the CONVERT function between SQL types,
421			otherwise
422			<FALSE/>
423			.
424		@returns
425			<TRUE/> if so
426		@throws SQLException
427			if a database access error occurs.
428	 */
429	boolean supportsTypeConversion() raises (SQLException);
430	//-------------------------------------------------------------------------
431
432	/** 	<TRUE/>
433			, if the Database supports the CONVERT between the given SQL types
434			otherwise
435			<FALSE/>
436			.
437		@returns
438			<TRUE/> if so
439		@throws SQLException
440			if a database access error occurs.
441	 */
442	boolean supportsConvert([in]long fromType, [in]long toType)
443		raises (SQLException);
444	//-------------------------------------------------------------------------
445
446	/** Are table correlation names supported?
447		@returns
448			<TRUE/> if so
449		@throws SQLException
450			if a database access error occurs.
451	 */
452	boolean supportsTableCorrelationNames() raises (SQLException);
453	//-------------------------------------------------------------------------
454
455	/** If table correlation names are supported, are they restricted
456		to be different from the names of the tables?
457		@returns
458			<TRUE/> if so
459		@throws SQLException
460			if a database access error occurs.
461	 */
462	boolean supportsDifferentTableCorrelationNames()
463		raises (SQLException);
464	//-------------------------------------------------------------------------
465
466	/** Are expressions in "ORDER BY" lists supported?
467		@returns
468			<TRUE/> if so
469		@throws SQLException
470			if a database access error occurs.
471	 */
472	boolean supportsExpressionsInOrderBy() raises (SQLException);
473	//-------------------------------------------------------------------------
474
475	/** Can an "ORDER BY" clause use columns not in the SELECT statement?
476		@returns
477			<TRUE/> if so
478		@throws SQLException
479			if a database access error occurs.
480	 */
481	boolean supportsOrderByUnrelated() raises (SQLException);
482	//-------------------------------------------------------------------------
483
484	/** Is some form of "GROUP BY" clause supported?
485		@returns
486			<TRUE/> if so
487		@throws SQLException
488			if a database access error occurs.
489	 */
490	boolean supportsGroupBy() raises (SQLException);
491	//-------------------------------------------------------------------------
492
493	/** Can a "GROUP BY" clause use columns not in the SELECT?
494		@returns
495			<TRUE/> if so
496		@throws SQLException
497			if a database access error occurs.
498	 */
499	boolean supportsGroupByUnrelated() raises (SQLException);
500	//-------------------------------------------------------------------------
501
502	/** Can a "GROUP BY" clause add columns not in the SELECT
503		provided it specifies all the columns in the SELECT?
504		@returns
505			<TRUE/> if so
506		@throws SQLException
507			if a database access error occurs.
508	 */
509	boolean supportsGroupByBeyondSelect() raises (SQLException);
510	//-------------------------------------------------------------------------
511
512	/** Is the escape character in "LIKE" clauses supported?
513		@returns
514			<TRUE/> if so
515		@throws SQLException
516			if a database access error occurs.
517	 */
518	boolean supportsLikeEscapeClause() raises (SQLException);
519	//-------------------------------------------------------------------------
520
521	/** Are multiple XResultSets from a single execute supported?
522		@returns
523			<TRUE/> if so
524		@throws SQLException
525			if a database access error occurs.
526	 */
527	boolean supportsMultipleResultSets() raises (SQLException);
528	//-------------------------------------------------------------------------
529
530	/** Can we have multiple transactions open at once (on different
531		connections)?
532		@returns
533			<TRUE/> if so
534		@throws SQLException
535			if a database access error occurs.
536	 */
537	boolean supportsMultipleTransactions() raises (SQLException);
538	//-------------------------------------------------------------------------
539
540	/** Can columns be defined as non-nullable?
541		@returns
542			<TRUE/> if so
543		@throws SQLException
544			if a database access error occurs.
545	 */
546	boolean supportsNonNullableColumns() raises (SQLException);
547	//-------------------------------------------------------------------------
548
549	/** 	<TRUE/>, if the database supports ODBC Minimum SQL grammar,
550			otherwise <FALSE/>.
551		@returns
552			<TRUE/> if so
553		@throws SQLException
554			if a database access error occurs.
555	 */
556	boolean supportsMinimumSQLGrammar() raises (SQLException);
557	//-------------------------------------------------------------------------
558
559	/** <TRUE/>, if the database supports ODBC Core SQL grammar,
560			otherwise <FALSE/>.
561			@returns
562			<TRUE/> if so
563		@throws SQLException
564			if a database access error occurs.
565	 */
566	boolean supportsCoreSQLGrammar() raises (SQLException);
567	//-------------------------------------------------------------------------
568
569	/**
570			<TRUE/>, if the database supports ODBC Extended SQL grammar,
571			otherwise <FALSE/>.
572			@returns
573			<TRUE/> if so
574		@throws SQLException
575			if a database access error occurs.
576	 */
577	boolean supportsExtendedSQLGrammar() raises (SQLException);
578	//-------------------------------------------------------------------------
579
580	/** @returns
581			<TRUE/>, if the database supports ANSI92 entry level SQL grammar,
582			otherwise <FALSE/>.
583			@throws SQLException
584			if a database access error occurs.
585	 */
586	boolean supportsANSI92EntryLevelSQL() raises (SQLException);
587	//-------------------------------------------------------------------------
588
589	/** @returns
590			<TRUE/>, if the database supports ANSI92 intermediate SQL grammar,
591			otherwise <FALSE/>.
592			@throws SQLException
593			if a database access error occurs.
594	 */
595	boolean supportsANSI92IntermediateSQL() raises (SQLException);
596	//-------------------------------------------------------------------------
597
598	/** @returns
599			<TRUE/>, if the database supports ANSI92 full SQL grammar,
600			otherwise <FALSE/>.
601			@throws SQLException
602			if a database access error occurs.
603	 */
604	boolean supportsANSI92FullSQL() raises (SQLException);
605	//-------------------------------------------------------------------------
606
607	/** returns
608			<TRUE/>, if the Database supports SQL Integrity Enhancement Facility,
609			otherwise <FALSE/>.
610			@throws SQLException
611			if a database access error occurs.
612	 */
613	boolean supportsIntegrityEnhancementFacility() raises (SQLException);
614	//-------------------------------------------------------------------------
615
616	/** @returns
617			<TRUE/>, if some form of outer join is supported,
618			otherwise <FALSE/>.
619			@throws SQLException
620			if a database access error occurs.
621	 */
622	boolean supportsOuterJoins() raises (SQLException);
623	//-------------------------------------------------------------------------
624
625	/** @returns
626			<TRUE/>, if full nested outer joins are supported,
627			otherwise <FALSE/>.
628			@throws SQLException
629			if a database access error occurs.
630	 */
631	boolean supportsFullOuterJoins() raises (SQLException);
632	//-------------------------------------------------------------------------
633
634	/** @returns
635			<TRUE/>, if there is limited support for outer joins.
636			(This will be <TRUE/> if supportFullOuterJoins is <TRUE/>.)
637			<FALSE/> is returned otherwise.
638			@throws SQLException
639			if a database access error occurs.
640	 */
641	boolean supportsLimitedOuterJoins() raises (SQLException);
642	//-------------------------------------------------------------------------
643
644	/** return the database vendor's preferred term for "schema"
645		@returns
646			<TRUE/> if so
647		@throws SQLException
648			if a database access error occurs.
649	 */
650	string getSchemaTerm() raises (SQLException);
651	//-------------------------------------------------------------------------
652
653	/** return the database vendor's preferred term for "procedure"
654		@returns
655			<TRUE/> if so
656		@throws SQLException
657			if a database access error occurs.
658	 */
659	string getProcedureTerm() raises (SQLException);
660	//-------------------------------------------------------------------------
661
662	/** return the database vendor's preferred term for "catalog"
663		@returns
664			<TRUE/> if so
665		@throws SQLException
666			if a database access error occurs.
667	 */
668	string getCatalogTerm() raises (SQLException);
669	//-------------------------------------------------------------------------
670
671	/** Does a catalog appear at the start of a qualified table name?
672		(Otherwise it appears at the end)
673		@returns
674			<TRUE/> if so
675		@throws SQLException
676			if a database access error occurs.
677	 */
678	boolean isCatalogAtStart() raises (SQLException);
679	//-------------------------------------------------------------------------
680
681	/** return the separator between catalog and table name
682		@returns
683			<TRUE/> if so
684		@throws SQLException
685			if a database access error occurs.
686	 */
687	string getCatalogSeparator() raises (SQLException);
688	//-------------------------------------------------------------------------
689
690	/** Can a schema name be used in a data manipulation statement?
691		@returns
692			<TRUE/> if so
693		@throws SQLException
694			if a database access error occurs.
695	 */
696	boolean supportsSchemasInDataManipulation() raises (SQLException);
697	//-------------------------------------------------------------------------
698
699	/** Can a schema name be used in a procedure call statement?
700		@returns
701			<TRUE/> if so
702		@throws SQLException
703			if a database access error occurs.
704	 */
705	boolean supportsSchemasInProcedureCalls() raises (SQLException);
706	//-------------------------------------------------------------------------
707
708	/** Can a schema name be used in a table definition statement?
709		@returns
710			<TRUE/> if so
711		@throws SQLException
712			if a database access error occurs.
713	 */
714	boolean supportsSchemasInTableDefinitions() raises (SQLException);
715	//-------------------------------------------------------------------------
716
717	/** Can a schema name be used in an index definition statement?
718		@returns
719			<TRUE/> if so
720		@throws SQLException
721			if a database access error occurs.
722	 */
723	boolean supportsSchemasInIndexDefinitions() raises (SQLException);
724	//-------------------------------------------------------------------------
725
726	/** Can a schema name be used in a privilege definition statement?
727		@returns
728			<TRUE/> if so
729		@throws SQLException
730			if a database access error occurs.
731	 */
732	boolean supportsSchemasInPrivilegeDefinitions()
733		raises (SQLException);
734	//-------------------------------------------------------------------------
735
736	/** Can a catalog name be used in a data manipulation statement?
737		@returns
738			<TRUE/> if so
739		@throws SQLException
740			if a database access error occurs.
741	 */
742	boolean supportsCatalogsInDataManipulation() raises (SQLException);
743	//-------------------------------------------------------------------------
744
745	/** Can a catalog name be used in a procedure call statement?
746		@returns
747			<TRUE/> if so
748		@throws SQLException
749			if a database access error occurs.
750	 */
751	boolean supportsCatalogsInProcedureCalls() raises (SQLException);
752	//-------------------------------------------------------------------------
753
754	/** Can a catalog name be used in a table definition statement?
755		@returns
756			<TRUE/> if so
757		@throws SQLException
758			if a database access error occurs.
759	 */
760	boolean supportsCatalogsInTableDefinitions() raises (SQLException);
761	//-------------------------------------------------------------------------
762
763	/** Can a catalog name be used in an index definition statement?
764		@returns
765			<TRUE/> if so
766		@throws SQLException
767			if a database access error occurs.
768	 */
769	boolean supportsCatalogsInIndexDefinitions() raises (SQLException);
770	//-------------------------------------------------------------------------
771
772	/** Can a catalog name be used in a privilege definition statement?
773		@returns
774			<TRUE/> if so
775		@throws SQLException
776			if a database access error occurs.
777	 */
778	boolean supportsCatalogsInPrivilegeDefinitions()
779		raises (SQLException);
780	//-------------------------------------------------------------------------
781
782	/** Is positioned DELETE supported?
783		@returns
784			<TRUE/> if so
785		@throws SQLException
786			if a database access error occurs.
787	 */
788	boolean supportsPositionedDelete() raises (SQLException);
789	//-------------------------------------------------------------------------
790
791	/** Is positioned UPDATE supported?
792		@returns
793			<TRUE/> if so
794		@throws SQLException
795			if a database access error occurs.
796	 */
797	boolean supportsPositionedUpdate() raises (SQLException);
798	//-------------------------------------------------------------------------
799
800	/** Is SELECT for UPDATE supported?
801		@returns
802			<TRUE/> if so
803		@throws SQLException
804			if a database access error occurs.
805	 */
806	boolean supportsSelectForUpdate() raises (SQLException);
807	//-------------------------------------------------------------------------
808
809	/** Are stored procedure calls using the stored procedure escape
810		syntax supported?
811			@returns
812			<TRUE/> if so
813		@throws SQLException
814			if a database access error occurs.
815	 */
816	boolean supportsStoredProcedures() raises (SQLException);
817	//-------------------------------------------------------------------------
818
819	/** Are subqueries in comparison expressions supported?
820		@returns
821			<TRUE/> if so
822		@throws SQLException
823			if a database access error occurs.
824	 */
825	boolean supportsSubqueriesInComparisons() raises (SQLException);
826	//-------------------------------------------------------------------------
827
828	/** Are subqueries in 'exists' expressions supported?
829		@returns
830			<TRUE/> if so
831		@throws SQLException
832			if a database access error occurs.
833	 */
834	boolean supportsSubqueriesInExists() raises (SQLException);
835	//-------------------------------------------------------------------------
836
837	/** Are subqueries in 'in' statements supported?
838		@returns
839			<TRUE/> if so
840		@throws SQLException
841			if a database access error occurs.
842	 */
843	boolean supportsSubqueriesInIns() raises (SQLException);
844	//-------------------------------------------------------------------------
845
846	/** Are subqueries in quantified expressions supported?
847		@returns
848			<TRUE/> if so
849		@throws SQLException
850			if a database access error occurs.
851	 */
852	boolean supportsSubqueriesInQuantifieds() raises (SQLException);
853	//-------------------------------------------------------------------------
854
855	/** Are correlated subqueries supported?
856		@returns
857			<TRUE/> if so
858		@throws SQLException
859			if a database access error occurs.
860	 */
861	boolean supportsCorrelatedSubqueries() raises (SQLException);
862	//-------------------------------------------------------------------------
863
864	/** Is SQL UNION supported?
865		@returns
866			<TRUE/> if so
867		@throws SQLException
868			if a database access error occurs.
869	 */
870	boolean supportsUnion() raises (SQLException);
871	//-------------------------------------------------------------------------
872
873	/** Is SQL UNION ALL supported?
874		@returns
875			<TRUE/> if so
876		@throws SQLException
877			if a database access error occurs.
878	 */
879	boolean supportsUnionAll() raises (SQLException);
880	//-------------------------------------------------------------------------
881
882	/** Can cursors remain open across commits?
883		@returns
884			<TRUE/> if so
885		@throws SQLException
886			if a database access error occurs.
887	 */
888	boolean supportsOpenCursorsAcrossCommit() raises (SQLException);
889	//-------------------------------------------------------------------------
890
891	/** Can cursors remain open across rollbacks?
892		@returns
893			<TRUE/> if so
894		@throws SQLException
895			if a database access error occurs.
896	 */
897	boolean supportsOpenCursorsAcrossRollback() raises (SQLException);
898	//-------------------------------------------------------------------------
899
900	/** Can statements remain open across commits?
901		@returns
902			<TRUE/> if so
903		@throws SQLException
904			if a database access error occurs.
905	 */
906	boolean supportsOpenStatementsAcrossCommit() raises (SQLException);
907	//-------------------------------------------------------------------------
908
909	/** Can statements remain open across rollbacks?
910		@returns
911			<TRUE/> if so
912		@throws SQLException
913			if a database access error occurs.
914	 */
915	boolean supportsOpenStatementsAcrossRollback()
916		raises (SQLException);
917    //-------------------------------------------------------------------------
918
919	/** return the maximal number of hex characters in an inline binary literal
920		@returns
921			<TRUE/> if so
922		@throws SQLException
923			if a database access error occurs.
924	 */
925	long getMaxBinaryLiteralLength() raises (SQLException);
926	//-------------------------------------------------------------------------
927
928	/** return the max length for a character literal
929		@returns
930			<TRUE/> if so
931		@throws SQLException
932			if a database access error occurs.
933	 */
934	long getMaxCharLiteralLength() raises (SQLException);
935	//-------------------------------------------------------------------------
936
937	/** return the limit on column name length
938		@returns
939			<TRUE/> if so
940		@throws SQLException
941			if a database access error occurs.
942	 */
943	long getMaxColumnNameLength() raises (SQLException);
944	//-------------------------------------------------------------------------
945
946	/** return the maximum number of columns in a "GROUP BY" clause
947		@returns
948			<TRUE/> if so
949		@throws SQLException
950			if a database access error occurs.
951	 */
952	long getMaxColumnsInGroupBy() raises (SQLException);
953	//-------------------------------------------------------------------------
954
955	/** return the maximum number of columns allowed in an index
956		@returns
957			<TRUE/> if so
958		@throws SQLException
959			if a database access error occurs.
960	 */
961	long getMaxColumnsInIndex() raises (SQLException);
962	//-------------------------------------------------------------------------
963
964	/** return the maximum number of columns in an "ORDER BY" clause
965		@returns
966			<TRUE/> if so
967		@throws SQLException
968			if a database access error occurs.
969	 */
970	long getMaxColumnsInOrderBy() raises (SQLException);
971    //-------------------------------------------------------------------------
972
973	/** return the maximum number of columns in a "SELECT" list
974		@returns
975			<TRUE/> if so
976		@throws SQLException
977			if a database access error occurs.
978	 */
979	long getMaxColumnsInSelect() raises (SQLException);
980	//-------------------------------------------------------------------------
981
982	/** return the maximum number of columns in a table
983		@returns
984			<TRUE/> if so
985		@throws SQLException
986			if a database access error occurs.
987	 */
988	long getMaxColumnsInTable() raises (SQLException);
989	//-------------------------------------------------------------------------
990
991	/** return the number of active connections at a time to this database.
992		@returns
993			<TRUE/> if so
994		@throws SQLException
995			if a database access error occurs.
996	 */
997	long getMaxConnections() raises (SQLException);
998    //-------------------------------------------------------------------------
999
1000	/** return the maximum cursor name length
1001	@returns
1002			<TRUE/> if so
1003		@throws SQLException
1004			if a database access error occurs.
1005	 */
1006	long getMaxCursorNameLength() raises (SQLException);
1007	//-------------------------------------------------------------------------
1008
1009	/** return the maximum length of an index (in bytes)
1010		@returns
1011			<TRUE/> if so
1012		@throws SQLException
1013			if a database access error occurs.
1014	 */
1015	long getMaxIndexLength() raises (SQLException);
1016    //-------------------------------------------------------------------------
1017
1018	/** return the maximum length allowed for a schema name
1019		@returns
1020			<TRUE/> if so
1021		@throws SQLException
1022			if a database access error occurs.
1023	 */
1024	long getMaxSchemaNameLength() raises (SQLException);
1025	//-------------------------------------------------------------------------
1026
1027	/** return the maximum length of a procedure name
1028		@returns
1029			<TRUE/> if so
1030		@throws SQLException
1031			if a database access error occurs.
1032	 */
1033	long getMaxProcedureNameLength() raises (SQLException);
1034	//-------------------------------------------------------------------------
1035
1036	/** return the maximum length of a catalog name
1037		@returns
1038			<TRUE/> if so
1039		@throws SQLException
1040			if a database access error occurs.
1041	 */
1042	long getMaxCatalogNameLength() raises (SQLException);
1043	//-------------------------------------------------------------------------
1044
1045	/** return the maximum length of a single row.
1046	@returns
1047			<TRUE/> if so
1048		@throws SQLException
1049			if a database access error occurs.
1050	 */
1051	long getMaxRowSize() raises (SQLException);
1052	//-------------------------------------------------------------------------
1053
1054	/** Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
1055		blobs?
1056		@returns
1057			<TRUE/> if so
1058		@throws SQLException
1059			if a database access error occurs.
1060	 */
1061	boolean doesMaxRowSizeIncludeBlobs() raises (SQLException);
1062	//-------------------------------------------------------------------------
1063
1064	/** return the maximum length of a SQL statement
1065		@returns
1066			<TRUE/> if so
1067		@throws SQLException
1068			if a database access error occurs.
1069	 */
1070	long getMaxStatementLength() raises (SQLException);
1071	//-------------------------------------------------------------------------
1072
1073	/** return the maximal number of open active statements at one time to this database
1074		@returns
1075			<TRUE/> if so
1076		@throws SQLException
1077			if a database access error occurs.
1078	 */
1079	long getMaxStatements() raises (SQLException);
1080	//-------------------------------------------------------------------------
1081
1082	/** return the maximum length of a table name
1083		@returns
1084			<TRUE/> if so
1085		@throws SQLException
1086			if a database access error occurs.
1087	 */
1088	long getMaxTableNameLength() raises (SQLException);
1089	//-------------------------------------------------------------------------
1090
1091	/** return the maximum number of tables in a SELECT statement
1092		@returns
1093			<TRUE/> if so
1094		@throws SQLException
1095			if a database access error occurs.
1096	 */
1097	long getMaxTablesInSelect() raises (SQLException);
1098	//-------------------------------------------------------------------------
1099
1100	/** return the maximum length of a user name
1101		@returns
1102			<TRUE/> if so
1103		@throws SQLException
1104			if a database access error occurs.
1105	 */
1106	long getMaxUserNameLength() raises (SQLException);
1107	//-------------------------------------------------------------------------
1108
1109	/** return the database default transaction isolation level.
1110		The values are defined in
1111		<type scope="com::sun::star::sdbc">TransactionIsolation</type>.
1112		@returns
1113			<TRUE/> if so
1114		@throws SQLException
1115			if a database access error occurs.
1116		@see com::sun::star::sdbc::XConnection
1117	 */
1118	long getDefaultTransactionIsolation() raises (SQLException);
1119    //-------------------------------------------------------------------------
1120
1121	/** support the Database transactions?
1122		If not, invoking the method
1123		<member scope="com::sun::star::sdbc">XConnection::commit()</member>
1124		is a noop and the
1125		isolation level is TransactionIsolation_NONE.
1126		@returns
1127			<TRUE/> if so
1128		@throws SQLException
1129			if a database access error occurs.
1130	 */
1131	boolean supportsTransactions() raises (SQLException);
1132	//-------------------------------------------------------------------------
1133
1134	/** Does this database support the given transaction isolation level?
1135		@returns
1136			<TRUE/> if so
1137		@throws SQLException
1138			if a database access error occurs.
1139 @see com::sun::star::sdbc::Connection
1140	 */
1141	boolean supportsTransactionIsolationLevel([in]long level)
1142							raises (SQLException);
1143	//-------------------------------------------------------------------------
1144
1145	/** support the Database both data definition and data manipulation statements
1146		within a transaction?
1147		@returns
1148			<TRUE/> if so
1149		@throws SQLException
1150			if a database access error occurs.
1151<!-- JRH: Unclear on the intent of these many support questions.
1152		If asking, it should state, "Does the Database support both ....?
1153		If declaring, it should state something like the following:
1154
1155		metadata: 	supportsDataDefinitionAndDataManipulationTransactions
1156
1157	"provides support for both data definition and data manipulation statements within a transaction."
1158 -->	 */
1159	boolean supportsDataDefinitionAndDataManipulationTransactions()
1160							 raises (SQLException);
1161    //-------------------------------------------------------------------------
1162
1163	/** are only data manipulation statements within a transaction
1164		supported?
1165		@returns
1166			<TRUE/> if so
1167		@throws SQLException
1168			if a database access error occurs.
1169	 */
1170	boolean supportsDataManipulationTransactionsOnly()
1171							raises (SQLException);
1172    //-------------------------------------------------------------------------
1173
1174	/** does a data definition statement within a transaction force the
1175		transaction to commit?
1176		@returns
1177			<TRUE/> if so
1178		@throws SQLException
1179			if a database access error occurs.
1180	 */
1181	boolean dataDefinitionCausesTransactionCommit()
1182							raises (SQLException);
1183    //-------------------------------------------------------------------------
1184
1185	/** is a data definition statement within a transaction ignored?
1186		@returns
1187			<TRUE/> if so
1188		@throws SQLException
1189			if a database access error occurs.
1190	 */
1191	boolean dataDefinitionIgnoredInTransactions()
1192							raises (SQLException);
1193    //-------------------------------------------------------------------------
1194
1195	/** Gets a description of the stored procedures available in a
1196		catalog.
1197
1198
1199		<p>
1200		Only procedure descriptions matching the schema and
1201		procedure name criteria are returned. They are ordered by
1202		PROCEDURE_SCHEM, and PROCEDURE_NAME.
1203		</p>
1204		<p>
1205		Each procedure description has the following columns:
1206		</p>
1207		<ol>
1208		<li>
1209		<b>PROCEDURE_CAT</b> string => procedure catalog (may be <NULL/>)
1210		</li>
1211		<li>
1212		<b>PROCEDURE_SCHEM</b> string => procedure schema (may be <NULL/>)
1213		</li>
1214		<li>
1215		<b>PROCEDURE_NAME</b> string => procedure name
1216		</li>
1217		<li> reserved for future use
1218		</li>
1219		<li> reserved for future use
1220		</li>
1221		<li> reserved for future use
1222		</li>
1223		<li>
1224		<b>REMARKS</b> string => explanatory comment on the procedure
1225		</li>
1226		<li>
1227		<b>PROCEDURE_TYPE</b> short => kind of procedure:
1228		<ul>
1229		<li> UNKNOWN - May return a result
1230		</li>
1231		<li> NO - Does not return a result
1232		</li>
1233		<li> RETURN - Returns a result
1234		</li>
1235		</ul>
1236		</li>
1237		</ol>
1238		@param catalog
1239			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1240		@param schemaPattern
1241			a schema name pattern; "" retrieves those without a schema
1242		@param procedureNamePattern
1243			a procedure name pattern
1244		@returns
1245			each row is a procedure description
1246		@throws SQLException
1247			if a database access error occurs.
1248	 */
1249	XResultSet getProcedures([in]any catalog, [in]string schemaPattern,
1250					[in]string procedureNamePattern) raises (SQLException);
1251	//-------------------------------------------------------------------------
1252
1253	/** gets a description of a catalog's stored procedure parameters
1254		and result columns.
1255
1256
1257		<p>
1258		Only descriptions matching the schema, procedure and
1259		parameter name criteria are returned. They are ordered by
1260		PROCEDURE_SCHEM and PROCEDURE_NAME. Within this, the return value,
1261		if any, is first. Next are the parameter descriptions in call
1262		order. The column descriptions follow in column number order.
1263		</p>
1264		<p>Each row in the XResultSet is a parameter description or
1265		column description with the following fields:
1266		</p>
1267		<ol>
1268		<li>
1269		<b>PROCEDURE_CAT</b> string => procedure catalog (may be <NULL/>)
1270		</li>
1271		<li>
1272		<b>PROCEDURE_SCHEM</b> string => procedure schema (may be <NULL/>)
1273		</li>
1274		<li>
1275		<b>PROCEDURE_NAME</b> string => procedure name
1276		</li>
1277		<li>
1278		<b>COLUMN_NAME</b> string => column/parameter name
1279		</li>
1280		<li>
1281		<b>COLUMN_TYPE</b> Short => kind of column/parameter:
1282		<ul>
1283		<li> UNKNOWN - nobody knows
1284		</li>
1285		<li> IN - IN parameter
1286		</li>
1287		<li> INOUT - INOUT parameter
1288		</li>
1289		<li> OUT - OUT parameter
1290		</li>
1291		<li> RETURN - procedure return value
1292		</li>
1293		<li> RESULT - result column in XResultSet
1294		</li>
1295		</ul>
1296		</li>
1297		<li>
1298		<b>DATA_TYPE</b> short => SQL type from java.sql.Types
1299		</li>
1300		<li>
1301		<b>TYPE_NAME</b> string => SQL type name, for a UDT type the
1302		type name is fully qualified
1303		</li>
1304		<li>
1305		<b>PRECISION</b> long => precision
1306		</li>
1307		<li>
1308		<b>LENGTH</b> long => length in bytes of data
1309		</li>
1310		<li>
1311		<b>SCALE</b> short => scale
1312		</li>
1313		<li>
1314		<b>RADIX</b> short => radix
1315		</li>
1316		<li>
1317		<b>NULLABLE</b> short => can it contain NULL?
1318		<ul>
1319		<li> NO_NULLS - does not allow NULL values
1320		</li>
1321		<li> NULLABLE - allows NULL values
1322		</li>
1323		<li> NULLABLE_UNKNOWN - nullability unknown
1324		</li>
1325		</ul>
1326		</li>
1327		<li>
1328		<b>REMARKS</b> string => comment describing parameter/column
1329		</li>
1330		</ol>
1331		<p>
1332		<b>Note:</b> Some databases may not return the column
1333		descriptions for a procedure. Additional columns beyond
1334		REMARKS can be defined by the database.
1335		</p>
1336		@param catalog
1337			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1338		@param schemaPattern
1339			a schema name pattern; "" retrieves those without a schema
1340		@param procedureNamePattern
1341			a procedure name pattern
1342		@param columnNamePattern
1343			a column name pattern
1344		@returns
1345			each row describes a stored procedure parameter or column
1346		@throws SQLException
1347			if a database access error occurs.
1348	 */
1349	XResultSet getProcedureColumns([in]any catalog, [in]string schemaPattern,
1350								   [in]string procedureNamePattern,
1351								   [in]string columnNamePattern)
1352						raises (SQLException);
1353    //-------------------------------------------------------------------------
1354
1355	/** gets a description of tables available in a catalog.
1356
1357
1358		<p>Only table descriptions matching the catalog, schema, table
1359		name, and type criteria are returned. They are ordered by
1360		TABLE_TYPE, TABLE_SCHEM, and TABLE_NAME.
1361		</p>
1362		<p>Each table description has the following columns:
1363		</p>
1364		<ol>
1365		<li>
1366		<b>TABLE_CAT</b> string => table catalog (may be <NULL/>)
1367		</li>
1368		<li>
1369		<b>TABLE_SCHEM</b> string => table schema (may be <NULL/>)
1370		</li>
1371		<li>
1372		<b>TABLE_NAME</b> string => table name
1373		</li>
1374		<li>
1375		<b>TABLE_TYPE</b> string => table type. Typical types are "TABLE",
1376		"VIEW",	"SYSTEM TABLE", "GLOBAL TEMPORARY",
1377		"LOCAL TEMPORARY", "ALIAS", "SYNONYM".
1378		</li>
1379		<li>
1380		<b>REMARKS</b> string => explanatory comment on the table
1381		</li>
1382		</ol>
1383		<p>
1384		<b>Note:</b> Some databases may not return information for
1385		all tables.
1386		</p>
1387		@param catalog
1388			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1389		@param schemaPattern
1390			a schema name pattern; "" retrieves those without a schema
1391		@param tableNamePattern
1392			a table name pattern
1393		@param types
1394			a list of table types to include
1395		@returns
1396			each row is a table description
1397		@throws SQLException
1398			if a database access error occurs.
1399	 */
1400	XResultSet getTables([in]any catalog, [in]string schemaPattern,
1401		[in]string tableNamePattern, [in]sequence<string> types)
1402		raises (SQLException);
1403	//-------------------------------------------------------------------------
1404
1405	/** Gets the schema names available in this database. The results
1406		are ordered by schema name.
1407
1408
1409		<p>The schema column is:
1410		</p>
1411		<ol>
1412		<li>
1413		<b>TABLE_SCHEM</b> string => schema name
1414		</li>
1415		</ol>
1416		@returns
1417			each row has a single String column that is a schema name
1418		@throws SQLException
1419			if a database access error occurs.
1420	 */
1421	XResultSet getSchemas() raises (SQLException);
1422	//-------------------------------------------------------------------------
1423
1424	/** gets the catalog names available in this database. The results
1425		are ordered by catalog name.
1426
1427
1428		<p>The catalog column is:
1429		</p>
1430		<ol>
1431		<li>
1432		<b>TABLE_CAT</b> string => catalog name
1433		</li>
1434		</ol>
1435		@returns
1436			each row has a single String column that is a catalog name
1437		@throws SQLException
1438			if a database access error occurs.
1439	 */
1440	XResultSet getCatalogs() raises (SQLException);
1441	//-------------------------------------------------------------------------
1442
1443	/** gets the table types available in this database. The results
1444		are ordered by table type.
1445
1446
1447		<p>The table type is:
1448		</p>
1449		<ol>
1450		<li>
1451		<b>TABLE_TYPE</b> string => table type. Typical types are "TABLE",
1452		"VIEW",	"SYSTEM TABLE", "GLOBAL TEMPORARY",
1453		"LOCAL TEMPORARY", "ALIAS", "SYNONYM".
1454		</li>
1455		</ol>
1456		@returns
1457			each row has a single String column that is a table type
1458		@throws SQLException
1459			if a database access error occurs.
1460	 */
1461	XResultSet getTableTypes() raises (SQLException);
1462	//-------------------------------------------------------------------------
1463
1464	/** gets a description of table columns available in
1465		the specified catalog.
1466
1467
1468		<p>Only column descriptions matching the catalog, schema, table
1469		and column name criteria are returned. They are ordered by
1470		TABLE_SCHEM, TABLE_NAME, and ORDINAL_POSITION.
1471		</p>
1472		<p>Each column description has the following columns:
1473		</p>
1474		<ol>
1475		<li>
1476		<b>TABLE_CAT</b> string => table catalog (may be <NULL/>)
1477		</li>
1478		<li>
1479		<b>TABLE_SCHEM</b> string => table schema (may be <NULL/>)
1480		</li>
1481		<li>
1482		<b>TABLE_NAME</b> string => table name
1483		</li>
1484		<li>
1485		<b>COLUMN_NAME</b> string => column name
1486		</li>
1487		<li>
1488		<b>DATA_TYPE</b> short => SQL type from java.sql.Types
1489		</li>
1490		<li>
1491		<b>TYPE_NAME</b> string => Data source dependent type name,
1492		for a UDT the type name is fully qualified
1493		</li>
1494		<li>
1495		<b>COLUMN_SIZE</b> long => column size. For char or date
1496		types this is the maximum number of characters, for numeric or
1497		decimal types this is precision.
1498		</li>
1499		<li>
1500		<b>BUFFER_LENGTH</b> is not used.
1501		</li>
1502		<li>
1503		<b>DECIMAL_DIGITS</b> long => the number of fractional digits
1504		</li>
1505		<li>
1506		<b>NUM_PREC_RADIX</b> long => Radix (typically either 10 or 2)
1507		</li>
1508		<li>
1509		<b>NULLABLE</b> long => is NULL allowed?
1510		<ul>
1511		<li> NO_NULLS - might not allow NULL values
1512		</li>
1513		<li> NULABLE - definitely allows NULL values
1514		</li>
1515		<li> NULLABLE_UNKNOWN - nullability unknown
1516		</li>
1517		</ul>
1518		</li>
1519		<li>
1520		<b>REMARKS</b> string => comment describing column (may be <NULL/>)
1521		</li>
1522		<li>
1523		<b>COLUMN_DEF</b> string => default value (may be <NULL/>)
1524		</li>
1525		<li>
1526		<b>SQL_DATA_TYPE</b> long => unused
1527		</li>
1528		<li>
1529		<b>SQL_DATETIME_SUB</b> long => unused
1530		</li>
1531		<li>
1532		<b>CHAR_OCTET_LENGTH</b> long => for char types the
1533		maximum number of bytes in the column
1534		</li>
1535		<li>
1536		<b>ORDINAL_POSITION</b> int	=> index of column in table
1537		(starting at 1)
1538		</li>
1539		<li>
1540		<b>IS_NULLABLE</b> string => "NO" means column definitely
1541		does not allow NULL values; "YES" means the column might
1542		allow NULL values. An empty string means nobody knows.
1543		</li>
1544		</ol>
1545		@param catalog
1546			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1547		@param schemaPattern
1548			a schema name pattern; "" retrieves those without a schema
1549		@param tableNamePattern
1550			a table name pattern
1551		@param columnNamePattern
1552			a column name pattern
1553		@returns
1554			each row is a column description
1555		@throws SQLException
1556			if a database access error occurs.
1557	 */
1558	XResultSet getColumns([in]any catalog, [in]string schemaPattern,
1559		[in]string tableNamePattern, [in]string columnNamePattern)
1560					raises (SQLException);
1561	//-------------------------------------------------------------------------
1562
1563	/** gets a description of the access rights for a table's columns.
1564
1565
1566		<p>
1567		Only privileges matching the column name criteria are
1568		returned. They are ordered by COLUMN_NAME and PRIVILEGE.
1569		</p>
1570		<p>Each privilige description has the following columns:
1571		</p>
1572		<ol>
1573		<li>
1574		<b>TABLE_CAT</b> string => table catalog (may be <NULL/>)
1575		</li>
1576		<li>
1577		<b>TABLE_SCHEM</b> string => table schema (may be <NULL/>)
1578		</li>
1579		<li>
1580		<b>TABLE_NAME</b> string => table name
1581		</li>
1582		<li>
1583		<b>COLUMN_NAME</b> string => column name
1584		</li>
1585		<li>
1586		<b>GRANTOR</b> => grantor of access (may be <NULL/>)
1587		</li>
1588		<li>
1589		<b>GRANTEE</b> string => grantee of access
1590		</li>
1591		<li>
1592		<b>PRIVILEGE</b> string => name of access (SELECT,
1593		INSERT, UPDATE, REFERENCES, ...)
1594		</li>
1595		<li>
1596		<b>IS_GRANTABLE</b> string => "YES" if grantee is permitted
1597		to grant to others; "NO" if not; <NULL/> if unknown
1598		</li>
1599		</ol>
1600		@param catalog
1601			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1602		@param schema
1603			a schema name ; "" retrieves those without a schema
1604		@param table
1605			a table name
1606		@param columnNamePattern
1607			a column name pattern
1608		@returns
1609			each row is a column privilege description
1610		@throws SQLException
1611			if a database access error occurs.
1612	 */
1613	XResultSet getColumnPrivileges([in]any catalog, [in]string schema,
1614		[in]string table, [in]string columnNamePattern) raises (SQLException);
1615    //-------------------------------------------------------------------------
1616
1617	/** gets a description of the access rights for each table available
1618		in a catalog. Note that a table privilege applies to one or
1619		more columns in the table. It would be wrong to assume that
1620		this priviledge applies to all columns (this may be <TRUE/> for
1621		some systems but is not <TRUE/> for all.)
1622
1623
1624		<p>Only privileges matching the schema and table name
1625		criteria are returned. They are ordered by TABLE_SCHEM,
1626		TABLE_NAME, and PRIVILEGE.
1627		</p>
1628		<p>Each privilige description has the following columns:
1629		</p>
1630		<ol>
1631		<li>
1632		<b>TABLE_CAT</b> string => table catalog (may be <NULL/>)
1633		</li>
1634		<li>
1635		<b>TABLE_SCHEM</b> string => table schema (may be <NULL/>)
1636		</li>
1637		<li>
1638		<b>TABLE_NAME</b> string => table name
1639		</li>
1640		<li>
1641		<b>GRANTOR</b> => grantor of access (may be <NULL/>)
1642		</li>
1643		<li>
1644		<b>GRANTEE</b> string => grantee of access
1645		</li>
1646		<li>
1647		<b>PRIVILEGE</b> string => name of access (SELECT,
1648		INSERT, UPDATE, REFERENCES, ...)
1649		</li>
1650		<li>
1651		<b>IS_GRANTABLE</b> string => "YES" if grantee is permitted
1652		to grant to others; "NO" if not; <NULL/> if unknown
1653		</li>
1654		</ol>
1655		@param catalog
1656			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1657		@param schemaPattern
1658			a schema name pattern; "" retrieves those without a schema
1659		@param tableNamePattern
1660			a table name pattern
1661		@returns
1662			each row is a table privilege description
1663		@throws SQLException
1664			if a database access error occurs.
1665	 */
1666	XResultSet getTablePrivileges([in]any catalog, [in]string schemaPattern,
1667				[in]string tableNamePattern) raises (SQLException);
1668	//-------------------------------------------------------------------------
1669
1670	/** gets a description of a table's optimal set of columns that
1671		uniquely identifies a row. They are ordered by SCOPE.
1672
1673
1674		<p>Each column description has the following columns:
1675		</p>
1676		<ol>
1677		<li>
1678		<b>SCOPE</b> short => actual scope of result
1679		<ul>
1680		<li> TEMPORARY - very temporary, while using row
1681		</li>
1682		<li> TRANSACTION - valid for remainder of current transaction
1683		</li>
1684		<li> SESSION - valid for remainder of current session
1685		</li>
1686		</ul>
1687		</li>
1688		<li>
1689		<b>COLUMN_NAME</b> string => column name
1690		</li>
1691		<li>
1692		<b>DATA_TYPE</b> short => SQL data type from java.sql.Types
1693		</li>
1694		<li>
1695		<b>TYPE_NAME</b> string => Data source dependent type name,
1696		for a UDT the type name is fully qualified
1697		</li>
1698		<li>
1699		<b>COLUMN_SIZE</b> long => precision
1700		</li>
1701		<li>
1702		<b>BUFFER_LENGTH</b> long => not used
1703		</li>
1704		<li>
1705		<b>DECIMAL_DIGITS</b> short	 => scale
1706		</li>
1707		<li>
1708		<b>PSEUDO_COLUMN</b> short => is this a pseudo column
1709		like an Oracle ROWID
1710		<ul>
1711		<li> UNKNOWN - may or may not be pseudo column
1712		</li>
1713		<li> NOT_PSEUDO - is NOT a pseudo column
1714		</li>
1715		<li> PSEUDO - is a pseudo column
1716		</li>
1717		</ul>
1718		</li>
1719		</ol>
1720		@param catalog
1721			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1722		@param schema
1723			a schema name; "" retrieves those without a schema
1724		@param table
1725			a table name
1726		@param scope
1727			the scope of interest; use same values as SCOPE
1728		@param nullable
1729			include columns that are nullable?
1730		@returns
1731			each row is a column description
1732		@throws SQLException
1733			if a database access error occurs.
1734	 */
1735	XResultSet getBestRowIdentifier([in]any catalog, [in]string schema,
1736		[in]string table, [in]long scope, [in] boolean nullable)
1737		raises (SQLException);
1738	//-------------------------------------------------------------------------
1739
1740	/** gets a description of a table's columns that are automatically
1741		updated when any value in a row is updated. They are
1742		unordered.
1743
1744
1745		<p>Each column description has the following columns:
1746		</p>
1747		<ol>
1748		<li>
1749		<b>SCOPE</b> short => is not used
1750		</li>
1751		<li>
1752		<b>COLUMN_NAME</b> string => column name
1753		</li>
1754		<li>
1755		<b>DATA_TYPE</b> short => SQL data type from java.sql.Types
1756		</li>
1757		<li>
1758		<b>TYPE_NAME</b> string => Data source dependent type name
1759		</li>
1760		<li>
1761		<b>COLUMN_SIZE</b> long => precision
1762		</li>
1763		<li>
1764		<b>BUFFER_LENGTH</b> long => length of column value in bytes
1765		</li>
1766		<li>
1767		<b>DECIMAL_DIGITS</b> short	 => scale
1768		</li>
1769		<li>
1770		<b>PSEUDO_COLUMN</b> short => is this a pseudo column
1771		like an Oracle ROWID
1772		<ul>
1773		<li> UNKNOWN - may or may not be pseudo column
1774		</li>
1775		<li> NOT_PSEUDO - is NOT a pseudo column
1776		</li>
1777		<li> PSEUDO - is a pseudo column
1778		</li>
1779		</ul>
1780		</li>
1781		</ol>
1782		@param catalog
1783			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1784		@param schema
1785			a schema name; "" retrieves those without a schema
1786		@param table
1787			a table name
1788		@returns
1789			each row is a column description
1790		@throws SQLException
1791			if a database access error occurs.
1792	 */
1793	XResultSet getVersionColumns([in]any catalog, [in]string schema,
1794				[in]string table) raises (SQLException);
1795	//-------------------------------------------------------------------------
1796
1797	/** gets a description of a table's primary key columns. They
1798		are ordered by COLUMN_NAME.
1799
1800
1801		<p>Each primary key column description has the following columns:
1802		</p>
1803		<ol>
1804		<li>
1805		<b>TABLE_CAT</b> string => table catalog (may be <NULL/>)
1806		</li>
1807		<li>
1808		<b>TABLE_SCHEM</b> string => table schema (may be <NULL/>)
1809		</li>
1810		<li>
1811		<b>TABLE_NAME</b> string => table name
1812		</li>
1813		<li>
1814		<b>COLUMN_NAME</b> string => column name
1815		</li>
1816		<li>
1817		<b>KEY_SEQ</b> short => sequence number within primary key
1818		</li>
1819		<li>
1820		<b>PK_NAME</b> string => primary key name (may be <NULL/>)
1821		</li>
1822		</ol>
1823		@param catalog
1824			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1825		@param schema
1826			a schema name; "" retrieves those without a schema
1827		@param table
1828			a table name
1829		@returns
1830			each row is a primary key column description
1831		@throws SQLException
1832			if a database access error occurs.
1833	 */
1834	XResultSet getPrimaryKeys([in]any catalog, [in]string schema,
1835				[in]string table) raises (SQLException);
1836	//-------------------------------------------------------------------------
1837
1838	/** gets a description of the primary key columns that are
1839		referenced by a table's foreign key columns (the primary keys
1840		imported by a table). They are ordered by PKTABLE_CAT,
1841		PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ.
1842
1843
1844		<p>Each primary key column description has the following columns:
1845		</p>
1846		<ol>
1847		<li>
1848		<b>PKTABLE_CAT</b> string => primary key table catalog
1849		being imported (may be <NULL/>)
1850		</li>
1851		<li>
1852		<b>PKTABLE_SCHEM</b> string => primary key table schema
1853		being imported (may be <NULL/>)
1854		</li>
1855		<li>
1856		<b>PKTABLE_NAME</b> string => primary key table name
1857		being imported
1858		</li>
1859		<li>
1860		<b>PKCOLUMN_NAME</b> string => primary key column name
1861		being imported
1862		</li>
1863		<li>
1864		<b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>)
1865		</li>
1866		<li>
1867		<b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>)
1868		</li>
1869		<li>
1870		<b>FKTABLE_NAME</b> string => foreign key table name
1871		</li>
1872		<li>
1873		<b>FKCOLUMN_NAME</b> string => foreign key column name
1874		</li>
1875		<li>
1876		<b>KEY_SEQ</b> short => sequence number within foreign key
1877		</li>
1878		<li>
1879		<b>UPDATE_RULE</b> short => What happens to
1880		foreign key when primary is updated:
1881		<ul>
1882		<li> importedNoAction - do not allow update of primary
1883		key if it has been imported
1884		</li>
1885		<li> importedKeyCascade - change imported key to agree
1886		with primary key update
1887		</li>
1888		<li> importedKeySetNull - change imported key to NULL if
1889		its primary key has been updated
1890		</li>
1891		<li> importedKeySetDefault - change imported key to default values
1892		if its primary key has been updated
1893		</li>
1894		<li> importedKeyRestrict - same as importedKeyNoAction
1895		(for ODBC 2.x compatibility)
1896		</li>
1897		</ul>
1898		</li>
1899		<li>
1900		<b>DELETE_RULE</b> short => What happens to
1901		the foreign key when primary is deleted.
1902		<ul>
1903		<li> importedKeyNoAction - do not allow delete of primary
1904		key if it has been imported
1905		</li>
1906		<li> importedKeyCascade - delete rows that import a deleted key
1907		</li>
1908		<li> importedKeySetNull - change imported key to NULL if
1909		its primary key has been deleted
1910		</li>
1911		<li> importedKeyRestrict - same as importedKeyNoAction
1912		(for ODBC 2.x compatibility)
1913		</li>
1914		<li> importedKeySetDefault - change imported key to default if
1915		its primary key has been deleted
1916		</li>
1917		</ul>
1918		</li>
1919		<li>
1920		<b>FK_NAME</b> string => foreign key name (may be <NULL/>)
1921		</li>
1922		<li>
1923		<b>PK_NAME</b> string => primary key name (may be <NULL/>)
1924		</li>
1925		<li>
1926		<b>DEFERRABILITY</b> short => can the evaluation of foreign key
1927		constraints be deferred until commit
1928		<ul>
1929		<li> importedKeyInitiallyDeferred - see SQL92 for definition
1930		</li>
1931		<li> importedKeyInitiallyImmediate - see SQL92 for definition
1932		</li>
1933		<li> importedKeyNotDeferrable - see SQL92 for definition
1934		</li>
1935		</ul>
1936		</li>
1937		</ol>
1938		@param catalog
1939			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
1940		@param schema
1941			a schema name; "" retrieves those without a schema
1942		@param table
1943			a table name
1944		@returns
1945			each row is a primary key column description
1946		@throws SQLException
1947			if a database access error occurs.
1948	 */
1949	XResultSet getImportedKeys([in]any catalog, [in]string schema,
1950				[in]string table) raises (SQLException);
1951	//-------------------------------------------------------------------------
1952
1953	/** gets a description of the foreign key columns that reference a
1954		table's primary key columns (the foreign keys exported by a
1955		table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM,
1956		FKTABLE_NAME, and KEY_SEQ.
1957
1958
1959		<p>Each foreign key column description has the following columns:
1960		</p>
1961		<ol>
1962		<li>
1963		<b>PKTABLE_CAT</b> string => primary key table catalog (may be <NULL/>)
1964		</li>
1965		<li>
1966		<b>PKTABLE_SCHEM</b> string => primary key table schema (may be <NULL/>)
1967		</li>
1968		<li>
1969		<b>PKTABLE_NAME</b> string => primary key table name
1970		</li>
1971		<li>
1972		<b>PKCOLUMN_NAME</b> string => primary key column name
1973		</li>
1974		<li>
1975		<b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>)
1976		being exported (may be <NULL/>)
1977		</li>
1978		<li>
1979		<b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>)
1980		being exported (may be <NULL/>)
1981		</li>
1982		<li>
1983		<b>FKTABLE_NAME</b> string => foreign key table name
1984		being exported
1985		</li>
1986		<li>
1987		<b>FKCOLUMN_NAME</b> string => foreign key column name
1988		being exported
1989		</li>
1990		<li>
1991		<b>KEY_SEQ</b> short => sequence number within foreign key
1992		</li>
1993		<li>
1994		<b>UPDATE_RULE</b> short => What happens to
1995		foreign key when primary is updated:
1996		<ul>
1997		<li> NO_ACTION - do not allow update of primary
1998		key if it has been imported
1999		</li>
2000		<li> CASCADE - change imported key to agree
2001		with primary key update
2002		</li>
2003		<li> SET_NULL - change imported key to NULL if
2004		its primary key has been updated
2005		</li>
2006		<li> SET_DEFAULT - change imported key to default values
2007		if its primary key has been updated
2008		</li>
2009		<li> RESTRICT - same as importedKeyNoAction
2010		(for ODBC 2.x compatibility)
2011		</li>
2012		</ul>
2013		</li>
2014		<li>
2015		<b>DELETE_RULE</b> short => What happens to
2016		the foreign key when primary is deleted.
2017		<ul>
2018		<li> NO_ACTION - do not allow delete of primary
2019		key if it has been imported
2020		</li>
2021		<li> CASCADE - delete rows that import a deleted key
2022		</li>
2023		<li> SET_NULL - change imported key to NULL if
2024		its primary key has been deleted
2025		</li>
2026		<li> RESTRICT - same as importedKeyNoAction
2027		(for ODBC 2.x compatibility)
2028		</li>
2029		<li> SET_DEFAULT - change imported key to default if
2030		its primary key has been deleted
2031		</li>
2032		</ul>
2033		</li>
2034		<li>
2035		<b>FK_NAME</b> string => foreign key name (may be <NULL/>)
2036		</li>
2037		<li>
2038		<b>PK_NAME</b> string => primary key name (may be <NULL/>)
2039		</li>
2040		<li>
2041		<b>DEFERRABILITY</b> short => can the evaluation of foreign key
2042		constraints be deferred until commit
2043		<ul>
2044		<li> INITIALLY_DEFERRED - see SQL92 for definition
2045		</li>
2046		<li> INITIALLY_IMMEDIATE - see SQL92 for definition
2047		</li>
2048		<li> NONE - see SQL92 for definition
2049		</li>
2050		</ul>
2051		</li>
2052		</ol>
2053		@param catalog
2054			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
2055		@param schema
2056			a schema name; "" retrieves those without a schema
2057		@param table
2058			a table name
2059		@returns
2060			each row is a foreign key column description
2061		@throws SQLException
2062			if a database access error occurs.
2063	 */
2064	XResultSet getExportedKeys([in]any catalog, [in]string schema,
2065				[in]string table) raises (SQLException);
2066	//-------------------------------------------------------------------------
2067
2068	/** gets a description of the foreign key columns in the foreign key
2069		table that reference the primary key columns of the primary key
2070		table (describe how one table imports another's key.) This
2071		should normally return a single foreign key/primary key pair
2072		(most tables only import a foreign key from a table once.). They
2073		are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and
2074		KEY_SEQ.
2075
2076
2077		<p>Each foreign key column description has the following columns:
2078		</p>
2079		<ol>
2080		<li>
2081		<b>PKTABLE_CAT</b> string => primary key table catalog (may be <NULL/>)
2082		</li>
2083		<li>
2084		<b>PKTABLE_SCHEM</b> string => primary key table schema (may be <NULL/>)
2085		</li>
2086		<li>
2087		<b>PKTABLE_NAME</b> string => primary key table name
2088		</li>
2089		<li>
2090		<b>PKCOLUMN_NAME</b> string => primary key column name
2091		</li>
2092		<li>
2093		<b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>)
2094		being exported (may be <NULL/>)
2095		</li>
2096		<li>
2097		<b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>)
2098		being exported (may be <NULL/>)
2099		</li>
2100		<li>
2101		<b>FKTABLE_NAME</b> string => foreign key table name
2102		being exported
2103		</li>
2104		<li>
2105		<b>FKCOLUMN_NAME</b> string => foreign key column name
2106		being exported
2107		</li>
2108		<li>
2109		<b>KEY_SEQ</b> short => sequence number within foreign key
2110		</li>
2111		<li>
2112		<b>UPDATE_RULE</b> short => What happens to
2113		foreign key when primary is updated:
2114		<ul>
2115		<li> NO_ACTION - do not allow update of primary
2116		key if it has been imported
2117		</li>
2118		<li> CASCADE - change imported key to agree
2119		with primary key update
2120		</li>
2121		<li> SET_NULL - change imported key to NULL if
2122		its primary key has been updated
2123		</li>
2124		<li> SET_DEFAULT - change imported key to default values
2125		if its primary key has been updated
2126		</li>
2127		<li> RESTRICT - same as importedKeyNoAction
2128		(for ODBC 2.x compatibility)
2129		</li>
2130		</ul>
2131		</li>
2132		<li>
2133		<b>DELETE_RULE</b> short => What happens to
2134		the foreign key when primary is deleted.
2135		<ul>
2136		<li> NO_ACTION - do not allow delete of primary
2137		key if it has been imported
2138		</li>
2139		<li> CASCADE - delete rows that import a deleted key
2140		</li>
2141		<li> SET_NULL - change imported key to NULL if
2142		its primary key has been deleted
2143		</li>
2144		<li> RESTRICT - same as importedKeyNoAction
2145		(for ODBC 2.x compatibility)
2146		</li>
2147		<li> SET_DEFAULT - change imported key to default if
2148		its primary key has been deleted
2149		</li>
2150		</ul>
2151		</li>
2152		<li>
2153		<b>FK_NAME</b> string => foreign key name (may be <NULL/>)
2154		</li>
2155		<li>
2156		<b>PK_NAME</b> string => primary key name (may be <NULL/>)
2157		</li>
2158		<li>
2159		<b>DEFERRABILITY</b> short => can the evaluation of foreign key
2160		constraints be deferred until commit
2161		<ul>
2162		<li> INITIALLY_DEFERRED - see SQL92 for definition
2163		</li>
2164		<li> INITIALLY_IMMEDIATE - see SQL92 for definition
2165		</li>
2166		<li> NONE - see SQL92 for definition
2167		</li>
2168		</ul>
2169		</li>
2170		</ol>
2171		@param primaryCatalog
2172			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
2173		@param primarySchema
2174			a schema name; "" retrieves those without a schema
2175		@param primaryTable
2176			the table name that exports the key
2177		@param foreignCatalog
2178			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
2179		@param foreignSchema
2180			a schema name; "" retrieves those without a schema
2181		@param foreignTable
2182			the table name that imports the key
2183		@returns
2184			each row is a foreign key column description
2185		@throws SQLException
2186			if a database access error occurs.
2187	 */
2188	XResultSet getCrossReference(
2189		[in]any primaryCatalog, [in]string primarySchema,
2190		[in]string primaryTable,
2191		[in]any foreignCatalog, [in]string foreignSchema,
2192		[in]string foreignTable) raises (SQLException);
2193    //-------------------------------------------------------------------------
2194
2195	/** gets a description of all the standard SQL types supported by
2196		this database. They are ordered by DATA_TYPE and then by how
2197		closely the data type maps to the corresponding SDBC SQL type.
2198
2199
2200
2201		<p>Each type description has the following columns:
2202		</p>
2203		<ol>
2204		<li>
2205		<b>TYPE_NAME</b> string => Type name
2206		</li>
2207		<li>
2208		<b>DATA_TYPE</b> short => SQL data type from java.sql.Types
2209		</li>
2210		<li>
2211		<b>PRECISION</b> long => maximum precision
2212		</li>
2213		<li>
2214		<b>LITERAL_PREFIX</b> string => prefix used to quote a literal
2215		(may be <NULL/>)
2216		</li>
2217		<li>
2218		<b>LITERAL_SUFFIX</b> string => suffix used to quote a literal
2219		(may be <NULL/>)
2220		</li>
2221		<li>
2222		<b>CREATE_PARAMS</b> string => parameters used in creating
2223		the type (may be <NULL/>)
2224		</li>
2225		<li>
2226		<b>NULLABLE</b> short => can you use NULL for this type?
2227		<ul>
2228		<li> NO_NULLS - does not allow NULL values
2229		</li>
2230		<li> NULLABLE - allows NULL values
2231		</li>
2232		<li> NULLABLE_UNKNOWN - nullability unknown
2233		</li>
2234		</ul>
2235		</li>
2236		<li>
2237		<b>CASE_SENSITIVE</b> boolean=> is it case sensitive?
2238		</li>
2239		<li>
2240		<b>SEARCHABLE</b> short => can you use "WHERE" based on this type:
2241		<ul>
2242		<li> NONE - No support
2243		</li>
2244		<li> CHAR - Only supported with WHERE .. LIKE
2245		</li>
2246		<li> BASIC - Supported except for WHERE .. LIKE
2247		</li>
2248		<li> FULL - Supported for all WHERE ..
2249		</li>
2250		</ul>
2251		</li>
2252		<li>
2253		<b>UNSIGNED_ATTRIBUTE</b> boolean => is it unsigned?
2254		</li>
2255		<li>
2256		<b>FIXED_PREC_SCALE</b> boolean => can it be a money value?
2257		</li>
2258		<li>
2259		<b>AUTO_INCREMENT</b> boolean => can it be used for an
2260		auto-increment value?
2261		</li>
2262		<li>
2263		<b>LOCAL_TYPE_NAME</b> string => localized version of type name
2264		(may be <NULL/>)
2265		</li>
2266		<li>
2267		<b>MINIMUM_SCALE</b> short => minimum scale supported
2268		</li>
2269		<li>
2270		<b>MAXIMUM_SCALE</b> short => maximum scale supported
2271		</li>
2272		<li>
2273		<b>SQL_DATA_TYPE</b> long => unused
2274		</li>
2275		<li>
2276		<b>SQL_DATETIME_SUB</b> long => unused
2277		</li>
2278		<li>
2279		<b>NUM_PREC_RADIX</b> long => usually 2 or 10
2280		</li>
2281		</ol>
2282		@returns
2283			each row is a SQL type description
2284		@throws SQLException
2285			if a database access error occurs.
2286	 */
2287	XResultSet getTypeInfo() raises (SQLException);
2288	//-------------------------------------------------------------------------
2289
2290	/** gets a description of a table's indices and statistics. They are
2291		ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION.
2292
2293
2294		<p>Each index column description has the following columns:
2295		</p>
2296		<ol>
2297		<li>
2298		<b>TABLE_CAT</b> string => table catalog (may be <NULL/>)
2299		</li>
2300		<li>
2301		<b>TABLE_SCHEM</b> string => table schema (may be <NULL/>)
2302		</li>
2303		<li>
2304		<b>TABLE_NAME</b> string => table name
2305		</li>
2306		<li>
2307		<b>NON_UNIQUE</b> boolean => Can index values be non-unique?
2308		<FALSE/> when TYPE is tableIndexStatistic
2309		</li>
2310		<li>
2311		<b>INDEX_QUALIFIER</b> string => index catalog (may be <NULL/>);
2312		<NULL/> when TYPE is tableIndexStatistic
2313		</li>
2314		<li>
2315		<b>INDEX_NAME</b> string => index name; <NULL/> when TYPE is
2316		tableIndexStatistic
2317		</li>
2318		<li>
2319		<b>TYPE</b> short => index type:
2320		<ul>
2321		<li> 0 - this identifies table statistics that are
2322		returned in conjuction with a table's index descriptions
2323		</li>
2324		<li> CLUSTERED - this is a clustered index
2325		</li>
2326		<li> HASHED - this is a hashed index
2327		</li>
2328		<li> OTHER - this is some other style of index
2329		</li>
2330		</ul>
2331		</li>
2332		<li>
2333		<b>ORDINAL_POSITION</b> short => column sequence number
2334		within index; zero when TYPE is tableIndexStatistic
2335		</li>
2336		<li>
2337		<b>COLUMN_NAME</b> string => column name; <NULL/> when TYPE is
2338		tableIndexStatistic
2339		</li>
2340		<li>
2341		<b>ASC_OR_DESC</b> string => column sort sequence, "A" => ascending,
2342		"D" => descending, may be <NULL/> if sort sequence is not supported;
2343		<NULL/> when TYPE is tableIndexStatistic
2344		</li>
2345		<li>
2346		<b>CARDINALITY</b> long => When TYPE is tableIndexStatistic, then
2347		this is the number of rows in the table; otherwise, it is the
2348		number of unique values in the index.
2349		</li>
2350		<li>
2351		<b>PAGES</b> long => When TYPE is  tableIndexStatisic then
2352		this is the number of pages used for the table, otherwise it
2353		is the number of pages used for the current index.
2354		</li>
2355		<li>
2356		<b>FILTER_CONDITION</b> string => Filter condition, if any.
2357		(may be <NULL/>)
2358		</li>
2359		</ol>
2360		@param catalog
2361			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
2362		@param schema
2363			a schema name; "" retrieves those without a schema
2364		@param table
2365			the table name that exports the key
2366		@param unique
2367			when <TRUE/>, return only indices for unique values; when <FALSE/>, return indices regardless of whether unique or not
2368		@param approximate
2369			when <TRUE/>, result is allowed to reflect approximate or out of data values; when <FALSE/>, results are requested to be accurate
2370		@returns
2371			each row is an index column description
2372		@throws SQLException
2373			if a database access error occurs.
2374	 */
2375	XResultSet getIndexInfo([in]any catalog, [in]string schema, [in]string table,
2376			[in]boolean unique, [in]boolean approximate)
2377					raises (SQLException);
2378    //-------------------------------------------------------------------------
2379
2380	/** Does the database support the given result set type?
2381		@param setType
2382			defined in
2383			<type scop="com::sun::star::sdbc">ResultSetType</type>
2384		@returns
2385			<TRUE/> if so
2386		@throws SQLException
2387			if a database access error occurs.
2388	 */
2389	boolean supportsResultSetType([in]long setType) raises (SQLException);
2390	//-------------------------------------------------------------------------
2391
2392	/** Does the database support the concurrency type in combination
2393		with the given result set type?
2394		@param setType
2395			defined in
2396			<type scop="com::sun::star::sdbc">ResultSetType</type>
2397		@param concurrency
2398			defined in
2399			<type scop="com::sun::star::sdbc">ResultSetConcurrency</type>
2400		@returns
2401			<TRUE/> if so
2402		@throws SQLException
2403			if a database access error occurs.
2404	 */
2405	boolean supportsResultSetConcurrency([in]long setType,
2406												  [in]long concurrency)
2407      raises (SQLException);
2408	//-------------------------------------------------------------------------
2409
2410	/** indicates whether a result set's own updates are visible.
2411		@param setType
2412			defined in
2413			<type scop="com::sun::star::sdbc">ResultSetType</type>
2414		@returns
2415			<TRUE/> if so
2416		@throws SQLException
2417			if a database access error occurs.
2418	 */
2419	boolean ownUpdatesAreVisible([in]long setType) raises (SQLException);
2420	//-------------------------------------------------------------------------
2421
2422	/** indicates whether a result set's own deletes are visible.
2423		@param setType
2424			defined in
2425			<type scop="com::sun::star::sdbc">ResultSetType</type>
2426		@returns
2427			<TRUE/> if so
2428		@throws SQLException
2429			if a database access error occurs.
2430	 */
2431	boolean ownDeletesAreVisible([in]long setType) raises (SQLException);
2432    //-------------------------------------------------------------------------
2433
2434	/** indicates whether a result set's own inserts are visible.
2435		@param setType
2436			defined in
2437			<type scop="com::sun::star::sdbc">ResultSetType</type>
2438		@returns
2439			<TRUE/> if so
2440		@throws SQLException
2441			if a database access error occurs.
2442	 */
2443	boolean ownInsertsAreVisible([in]long setType) raises (SQLException);
2444	//-------------------------------------------------------------------------
2445
2446	/** indicates whether updates made by others are visible.
2447		@param setType
2448			defined in
2449			<type scop="com::sun::star::sdbc">ResultSetType</type>
2450		@returns
2451			<TRUE/> if so
2452		@throws SQLException
2453			if a database access error occurs.
2454	 */
2455	boolean othersUpdatesAreVisible([in]long setType) raises (SQLException);
2456	//-------------------------------------------------------------------------
2457
2458	/** indicates whether deletes made by others are visible.
2459		@param setType
2460			defined in
2461			<type scop="com::sun::star::sdbc">ResultSetType</type>
2462		@returns
2463			<TRUE/> if so
2464		@throws SQLException
2465			if a database access error occurs.
2466	 */
2467	boolean othersDeletesAreVisible([in]long setType) raises (SQLException);
2468    //-------------------------------------------------------------------------
2469
2470	/** indicates whether inserts made by others are visible.
2471		@param setType
2472			defined in
2473			<type scop="com::sun::star::sdbc">ResultSetType</type>
2474		@returns
2475			<TRUE/> if so
2476		@throws SQLException
2477			if a database access error occurs.
2478	 */
2479	boolean othersInsertsAreVisible([in]long setType) raises (SQLException);
2480	//-------------------------------------------------------------------------
2481
2482	/** indicates whether or not a visible row update can be detected by
2483		calling the method
2484		<code>XResultSet.rowUpdated</code>.
2485		@param setType
2486			defined in
2487			<type scop="com::sun::star::sdbc">ResultSetType</type>
2488		@returns
2489			<TRUE/> if so
2490		@throws SQLException
2491			if a database access error occurs.
2492	 */
2493	boolean updatesAreDetected([in]long setType) raises (SQLException);
2494	//-------------------------------------------------------------------------
2495
2496	/** indicates whether or not a visible row delete can be detected by
2497		calling
2498		<member scope="com::sun::star::sdbc">XResultSet::rowDeleted()</member>
2499		. If deletesAreDetected()
2500		returns <FALSE/>, then deleted rows are removed from the result set.
2501		@param setType
2502			defined in
2503			<type scop="com::sun::star::sdbc">ResultSetType</type>
2504		@returns
2505			<TRUE/> if so
2506		@throws SQLException
2507			if a database access error occurs.
2508	 */
2509	boolean deletesAreDetected([in]long setType) raises (SQLException);
2510	//-------------------------------------------------------------------------
2511
2512	/** indicates whether or not a visible row insert can be detected
2513		by calling
2514		<member scope="com::sun::star::sdbc">XResultSet::rowInserted().</member>
2515		@param setType
2516			defined in
2517			<type scop="com::sun::star::sdbc">ResultSetType</type>
2518		@returns
2519			<TRUE/> if so
2520		@throws SQLException
2521			if a database access error occurs.
2522	 */
2523	boolean insertsAreDetected([in]long setType) raises (SQLException);
2524	//-------------------------------------------------------------------------
2525
2526	/** indicates whether the driver supports batch updates.
2527		@returns
2528			<TRUE/> if so
2529		@throws SQLException
2530			if a database access error occurs.
2531	 */
2532	boolean supportsBatchUpdates() raises (SQLException);
2533	//-------------------------------------------------------------------------
2534
2535	/** Gets a description of the user-defined types defined in a particular
2536		schema. Schema-specific UDTs may have type OBJECT, STRUCT,
2537		or DISTINCT.
2538
2539
2540		<p>Only types matching the catalog, schema, type name, and type
2541		criteria are returned. They are ordered by DATA_TYPE, TYPE_SCHEM,
2542		and TYPE_NAME. The type name parameter may be a fully-qualified
2543		name. In this case, the catalog and schemaPattern parameters are
2544		ignored.
2545		</p>
2546		<p>Each type description has the following columns:
2547		</p>
2548		<ol>
2549		<li>
2550		<b>TYPE_CAT</b> string => the type's catalog (may be <NULL/>)
2551		</li>
2552		<li>
2553		<b>TYPE_SCHEM</b> string => type's schema (may be <NULL/>)
2554		</li>
2555		<li>
2556		<b>TYPE_NAME</b> string => type name
2557		</li>
2558		<li>
2559		<b>CLASS_NAME</b> string => Java class name or service name
2560		</li>
2561		<li>
2562		<b>DATA_TYPE</b> string => type value.
2563		One of OBJECT, STRUCT, or DISTINCT
2564		</li>
2565		<li>
2566		<b>REMARKS</b> string => explanatory comment on the type
2567		</li>
2568		</ol>
2569		<p>
2570		<b>Note:</b> If the driver does not support UDTs, an empty
2571		result set is returned.
2572		</p>
2573		@param catalog
2574			a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria
2575		@param schemaPattern
2576			a schema name pattern; "" retrieves those without a schema
2577		@param typeNamePattern
2578			a type name pattern; may be a fully-qualified name
2579		@param types
2580			a list of user-named types to include (OBJECT, STRUCT, or DISTINCT)
2581		@returns
2582			each row is a type description
2583		@throws SQLException
2584			if a database access error occurs.
2585	 */
2586	XResultSet getUDTs([in]any catalog, [in]string schemaPattern,
2587		      [in]string typeNamePattern, [in]sequence<long> types)
2588      raises (SQLException);
2589	//-------------------------------------------------------------------------
2590
2591	/** retrieves the connection that produced this metadata object.
2592		@returns
2593			the Connection object
2594		@throws SQLException
2595			if a database access error occurs.
2596	 */
2597	XConnection getConnection() raises (SQLException);
2598};
2599
2600//=============================================================================
2601
2602}; }; }; };
2603
2604/*===========================================================================
2605===========================================================================*/
2606#endif
2607