| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| #ifndef __com_sun_star_sdbc_XDatabaseMetaData_idl__ |
| #define __com_sun_star_sdbc_XDatabaseMetaData_idl__ |
| |
| #ifndef __com_sun_star_uno_XInterface_idl__ |
| #include <com/sun/star/uno/XInterface.idl> |
| #endif |
| |
| #ifndef __com_sun_star_sdbc_SQLException_idl__ |
| #include <com/sun/star/sdbc/SQLException.idl> |
| #endif |
| |
| |
| module com { module sun { module star { module sdbc { |
| |
| published interface XResultSet; |
| published interface XConnection; |
| |
| /** provides comprehensive information about the database as a whole. |
| |
| |
| <p>Many of the methods here return lists of information in |
| the form of |
| <type scope="com::sun::star::sdbc">XResultSet</type> |
| objects. |
| You can use the normal <type scope="com::sun::star::sdbc">XResultSet</type> |
| methods such as |
| <member scope="com::sun::star::sdbc">XResultSet::getString()</member> |
| and |
| <member scope="com::sun::star::sdbc">XResultSet::getInt()</member> |
| to retrieve the data from these XResultSets. If a given form of |
| metadata is not available, these methods should throw a |
| <type scope="com::sun::star::sdbc">SQLException</type> |
| . |
| That a value of <type scope="com::sun::star::sdbc">XResultSet</type> is <NULL/> |
| can be chaked with the method <member scope="com::sun::star::sdbc">XResultSet::wasNull()</member>. |
| In the text only "(may be <NULL/>)" is mentioned for this case. |
| </p> |
| <p>Some of these methods take arguments that are String patterns. These |
| arguments all have names such as fooPattern. Within a pattern String, "%" |
| means match any substring of 0 or more characters, and "_" means match |
| any one character. Only metadata entries matching the search pattern |
| are returned. If a search pattern argument is set to <VOID/>, |
| that argument's criteria will be dropped from the search. |
| </p> |
| <p> |
| A |
| <type scope="com::sun::star::sdbc">SQLException</type> |
| will be thrown if a driver does not support |
| a meta data method. In the case of methods that return an XResultSet, |
| either an XResultSet (which may be empty) is returned or a |
| SQLException is thrown.</p> |
| */ |
| published interface XDatabaseMetaData: com::sun::star::uno::XInterface |
| { |
| |
| /** Can all the procedures returned by getProcedures be called by the |
| current user? |
| |
| @return |
| <TRUE/> |
| if the user is allowed to call all procedures returned by getProcedures |
| otherwise |
| <FALSE/> |
| . |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean allProceduresAreCallable() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can all the tables returned by getTable be SELECTed by the |
| current user? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean allTablesAreSelectable() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns the URL for the database connection |
| */ |
| string getURL() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns the user name from this database connection. |
| */ |
| string getUserName() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** checks if the database in read-only mode. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean isReadOnly() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are NULL values sorted high? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean nullsAreSortedHigh() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are NULL values sorted low? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean nullsAreSortedLow() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are NULL values sorted at the start regardless of sort order? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean nullsAreSortedAtStart() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are NULL values sorted at the end, regardless of sort order? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean nullsAreSortedAtEnd() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns the name of the database product. |
| */ |
| string getDatabaseProductName() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns the version of the database product. |
| */ |
| string getDatabaseProductVersion() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns the name of the SDBC driver. |
| */ |
| string getDriverName() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns the version number of the SDBC driver. |
| */ |
| string getDriverVersion() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns the SDBC driver major version number. |
| */ |
| long getDriverMajorVersion(); |
| //------------------------------------------------------------------------- |
| |
| /** returns the SDBC driver minor version number. |
| */ |
| long getDriverMinorVersion(); |
| //------------------------------------------------------------------------- |
| |
| /** use the database local files to save the tables. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean usesLocalFiles() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** use the database one local file to save for each table. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean usesLocalFilePerTable() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** use the database 'mixed case unquoted SQL identifiers' case sensitive. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsMixedCaseIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database treat mixed case unquoted SQL identifiers as |
| case insensitive and store them in upper case? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean storesUpperCaseIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database treat mixed case unquoted SQL identifiers as |
| case insensitive and store them in lower case? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean storesLowerCaseIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database treat mixed case unquoted SQL identifiers as |
| case insensitive and store them in mixed case? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean storesMixedCaseIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database treat mixed case quoted SQL identifiers as |
| case sensitive and as a result store them in mixed case? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsMixedCaseQuotedIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database treat mixed case quoted SQL identifiers as |
| case insensitive and store them in upper case? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean storesUpperCaseQuotedIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database treat mixed case quoted SQL identifiers as |
| case insensitive and store them in lower case? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean storesLowerCaseQuotedIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database treat mixed case quoted SQL identifiers as |
| case insensitive and store them in mixed case? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean storesMixedCaseQuotedIdentifiers() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** What's the string used to quote SQL identifiers? |
| This returns a space " " if identifier quoting is not supported. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getIdentifierQuoteString() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a comma-separated list of all a database's SQL keywords |
| that are NOT also SQL92 keywords. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getSQLKeywords() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a comma-separated list of math functions. These are the |
| X/Open CLI math function names used in the SDBC function escape |
| clause. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getNumericFunctions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a comma-separated list of string functions. These are the |
| X/Open CLI string function names used in the SDBC function escape |
| clause. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getStringFunctions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a comma-separated list of system functions. These are the |
| X/Open CLI system function names used in the SDBC function escape |
| clause. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getSystemFunctions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a comma-separated list of time and date functions. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getTimeDateFunctions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets the string that can be used to escape wildcard characters. |
| This is the string that can be used to escape '_' or '%' in |
| the string pattern style catalog search parameters. |
| |
| |
| <p> |
| The '_' character represents any single character. |
| </p> |
| <p> |
| The '%' character represents any sequence of zero or |
| more characters. |
| </p> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getSearchStringEscape() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets all the "extra" characters that can be used in unquoted |
| identifier names (those beyond a-z, A-Z, 0-9 and _). |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getExtraNameCharacters() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** support the Database "ALTER TABLE" with add column? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsAlterTableWithAddColumn() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** support the Database "ALTER TABLE" with drop column? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsAlterTableWithDropColumn() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** support the Database column aliasing? |
| |
| |
| <p> |
| The SQL AS clause can be used to provide names for |
| computed columns or to provide alias names for columns as required. |
| </p> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsColumnAliasing() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** are concatenations between NULL and non-NULL values NULL? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean nullPlusNonNullIsNull() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** <TRUE/> |
| , if the Database supports the CONVERT function between SQL types, |
| otherwise |
| <FALSE/> |
| . |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsTypeConversion() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** <TRUE/> |
| , if the Database supports the CONVERT between the given SQL types |
| otherwise |
| <FALSE/> |
| . |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsConvert([in]long fromType, [in]long toType) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are table correlation names supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsTableCorrelationNames() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** If table correlation names are supported, are they restricted |
| to be different from the names of the tables? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsDifferentTableCorrelationNames() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are expressions in "ORDER BY" lists supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsExpressionsInOrderBy() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can an "ORDER BY" clause use columns not in the SELECT statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsOrderByUnrelated() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Is some form of "GROUP BY" clause supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsGroupBy() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a "GROUP BY" clause use columns not in the SELECT? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsGroupByUnrelated() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a "GROUP BY" clause add columns not in the SELECT |
| provided it specifies all the columns in the SELECT? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsGroupByBeyondSelect() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Is the escape character in "LIKE" clauses supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsLikeEscapeClause() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are multiple XResultSets from a single execute supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsMultipleResultSets() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can we have multiple transactions open at once (on different |
| connections)? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsMultipleTransactions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can columns be defined as non-nullable? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsNonNullableColumns() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** <TRUE/>, if the database supports ODBC Minimum SQL grammar, |
| otherwise <FALSE/>. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsMinimumSQLGrammar() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** <TRUE/>, if the database supports ODBC Core SQL grammar, |
| otherwise <FALSE/>. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsCoreSQLGrammar() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** |
| <TRUE/>, if the database supports ODBC Extended SQL grammar, |
| otherwise <FALSE/>. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsExtendedSQLGrammar() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** @returns |
| <TRUE/>, if the database supports ANSI92 entry level SQL grammar, |
| otherwise <FALSE/>. |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsANSI92EntryLevelSQL() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** @returns |
| <TRUE/>, if the database supports ANSI92 intermediate SQL grammar, |
| otherwise <FALSE/>. |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsANSI92IntermediateSQL() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** @returns |
| <TRUE/>, if the database supports ANSI92 full SQL grammar, |
| otherwise <FALSE/>. |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsANSI92FullSQL() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** returns |
| <TRUE/>, if the Database supports SQL Integrity Enhancement Facility, |
| otherwise <FALSE/>. |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsIntegrityEnhancementFacility() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** @returns |
| <TRUE/>, if some form of outer join is supported, |
| otherwise <FALSE/>. |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsOuterJoins() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** @returns |
| <TRUE/>, if full nested outer joins are supported, |
| otherwise <FALSE/>. |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsFullOuterJoins() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** @returns |
| <TRUE/>, if there is limited support for outer joins. |
| (This will be <TRUE/> if supportFullOuterJoins is <TRUE/>.) |
| <FALSE/> is returned otherwise. |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsLimitedOuterJoins() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the database vendor's preferred term for "schema" |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getSchemaTerm() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the database vendor's preferred term for "procedure" |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getProcedureTerm() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the database vendor's preferred term for "catalog" |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getCatalogTerm() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does a catalog appear at the start of a qualified table name? |
| (Otherwise it appears at the end) |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean isCatalogAtStart() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the separator between catalog and table name |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| string getCatalogSeparator() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a schema name be used in a data manipulation statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSchemasInDataManipulation() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a schema name be used in a procedure call statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSchemasInProcedureCalls() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a schema name be used in a table definition statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSchemasInTableDefinitions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a schema name be used in an index definition statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSchemasInIndexDefinitions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a schema name be used in a privilege definition statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSchemasInPrivilegeDefinitions() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a catalog name be used in a data manipulation statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsCatalogsInDataManipulation() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a catalog name be used in a procedure call statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsCatalogsInProcedureCalls() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a catalog name be used in a table definition statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsCatalogsInTableDefinitions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a catalog name be used in an index definition statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsCatalogsInIndexDefinitions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can a catalog name be used in a privilege definition statement? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsCatalogsInPrivilegeDefinitions() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Is positioned DELETE supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsPositionedDelete() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Is positioned UPDATE supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsPositionedUpdate() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Is SELECT for UPDATE supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSelectForUpdate() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are stored procedure calls using the stored procedure escape |
| syntax supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsStoredProcedures() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are subqueries in comparison expressions supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSubqueriesInComparisons() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are subqueries in 'exists' expressions supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSubqueriesInExists() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are subqueries in 'in' statements supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSubqueriesInIns() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are subqueries in quantified expressions supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsSubqueriesInQuantifieds() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Are correlated subqueries supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsCorrelatedSubqueries() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Is SQL UNION supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsUnion() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Is SQL UNION ALL supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsUnionAll() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can cursors remain open across commits? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsOpenCursorsAcrossCommit() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can cursors remain open across rollbacks? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsOpenCursorsAcrossRollback() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can statements remain open across commits? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsOpenStatementsAcrossCommit() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Can statements remain open across rollbacks? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsOpenStatementsAcrossRollback() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximal number of hex characters in an inline binary literal |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxBinaryLiteralLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the max length for a character literal |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxCharLiteralLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the limit on column name length |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxColumnNameLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum number of columns in a "GROUP BY" clause |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxColumnsInGroupBy() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum number of columns allowed in an index |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxColumnsInIndex() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum number of columns in an "ORDER BY" clause |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxColumnsInOrderBy() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum number of columns in a "SELECT" list |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxColumnsInSelect() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum number of columns in a table |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxColumnsInTable() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the number of active connections at a time to this database. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxConnections() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum cursor name length |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxCursorNameLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length of an index (in bytes) |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxIndexLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length allowed for a schema name |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxSchemaNameLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length of a procedure name |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxProcedureNameLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length of a catalog name |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxCatalogNameLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length of a single row. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxRowSize() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY |
| blobs? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean doesMaxRowSizeIncludeBlobs() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length of a SQL statement |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxStatementLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximal number of open active statements at one time to this database |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxStatements() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length of a table name |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxTableNameLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum number of tables in a SELECT statement |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxTablesInSelect() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the maximum length of a user name |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| long getMaxUserNameLength() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** return the database default transaction isolation level. |
| The values are defined in |
| <type scope="com::sun::star::sdbc">TransactionIsolation</type>. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| @see com::sun::star::sdbc::XConnection |
| */ |
| long getDefaultTransactionIsolation() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** support the Database transactions? |
| If not, invoking the method |
| <member scope="com::sun::star::sdbc">XConnection::commit()</member> |
| is a noop and the |
| isolation level is TransactionIsolation_NONE. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsTransactions() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does this database support the given transaction isolation level? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| @see com::sun::star::sdbc::Connection |
| */ |
| boolean supportsTransactionIsolationLevel([in]long level) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** support the Database both data definition and data manipulation statements |
| within a transaction? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| <!-- JRH: Unclear on the intent of these many support questions. |
| If asking, it should state, "Does the Database support both ....? |
| If declaring, it should state something like the following: |
| |
| metadata: supportsDataDefinitionAndDataManipulationTransactions |
| |
| "provides support for both data definition and data manipulation statements within a transaction." |
| --> */ |
| boolean supportsDataDefinitionAndDataManipulationTransactions() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** are only data manipulation statements within a transaction |
| supported? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsDataManipulationTransactionsOnly() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** does a data definition statement within a transaction force the |
| transaction to commit? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean dataDefinitionCausesTransactionCommit() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** is a data definition statement within a transaction ignored? |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean dataDefinitionIgnoredInTransactions() |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Gets a description of the stored procedures available in a |
| catalog. |
| |
| |
| <p> |
| Only procedure descriptions matching the schema and |
| procedure name criteria are returned. They are ordered by |
| PROCEDURE_SCHEM, and PROCEDURE_NAME. |
| </p> |
| <p> |
| Each procedure description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>PROCEDURE_CAT</b> string => procedure catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>PROCEDURE_SCHEM</b> string => procedure schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>PROCEDURE_NAME</b> string => procedure name |
| </li> |
| <li> reserved for future use |
| </li> |
| <li> reserved for future use |
| </li> |
| <li> reserved for future use |
| </li> |
| <li> |
| <b>REMARKS</b> string => explanatory comment on the procedure |
| </li> |
| <li> |
| <b>PROCEDURE_TYPE</b> short => kind of procedure: |
| <ul> |
| <li> UNKNOWN - May return a result |
| </li> |
| <li> NO - Does not return a result |
| </li> |
| <li> RETURN - Returns a result |
| </li> |
| </ul> |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schemaPattern |
| a schema name pattern; "" retrieves those without a schema |
| @param procedureNamePattern |
| a procedure name pattern |
| @returns |
| each row is a procedure description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getProcedures([in]any catalog, [in]string schemaPattern, |
| [in]string procedureNamePattern) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of a catalog's stored procedure parameters |
| and result columns. |
| |
| |
| <p> |
| Only descriptions matching the schema, procedure and |
| parameter name criteria are returned. They are ordered by |
| PROCEDURE_SCHEM and PROCEDURE_NAME. Within this, the return value, |
| if any, is first. Next are the parameter descriptions in call |
| order. The column descriptions follow in column number order. |
| </p> |
| <p>Each row in the XResultSet is a parameter description or |
| column description with the following fields: |
| </p> |
| <ol> |
| <li> |
| <b>PROCEDURE_CAT</b> string => procedure catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>PROCEDURE_SCHEM</b> string => procedure schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>PROCEDURE_NAME</b> string => procedure name |
| </li> |
| <li> |
| <b>COLUMN_NAME</b> string => column/parameter name |
| </li> |
| <li> |
| <b>COLUMN_TYPE</b> Short => kind of column/parameter: |
| <ul> |
| <li> UNKNOWN - nobody knows |
| </li> |
| <li> IN - IN parameter |
| </li> |
| <li> INOUT - INOUT parameter |
| </li> |
| <li> OUT - OUT parameter |
| </li> |
| <li> RETURN - procedure return value |
| </li> |
| <li> RESULT - result column in XResultSet |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>DATA_TYPE</b> short => SQL type from java.sql.Types |
| </li> |
| <li> |
| <b>TYPE_NAME</b> string => SQL type name, for a UDT type the |
| type name is fully qualified |
| </li> |
| <li> |
| <b>PRECISION</b> long => precision |
| </li> |
| <li> |
| <b>LENGTH</b> long => length in bytes of data |
| </li> |
| <li> |
| <b>SCALE</b> short => scale |
| </li> |
| <li> |
| <b>RADIX</b> short => radix |
| </li> |
| <li> |
| <b>NULLABLE</b> short => can it contain NULL? |
| <ul> |
| <li> NO_NULLS - does not allow NULL values |
| </li> |
| <li> NULLABLE - allows NULL values |
| </li> |
| <li> NULLABLE_UNKNOWN - nullability unknown |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>REMARKS</b> string => comment describing parameter/column |
| </li> |
| </ol> |
| <p> |
| <b>Note:</b> Some databases may not return the column |
| descriptions for a procedure. Additional columns beyond |
| REMARKS can be defined by the database. |
| </p> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schemaPattern |
| a schema name pattern; "" retrieves those without a schema |
| @param procedureNamePattern |
| a procedure name pattern |
| @param columnNamePattern |
| a column name pattern |
| @returns |
| each row describes a stored procedure parameter or column |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getProcedureColumns([in]any catalog, [in]string schemaPattern, |
| [in]string procedureNamePattern, |
| [in]string columnNamePattern) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of tables available in a catalog. |
| |
| |
| <p>Only table descriptions matching the catalog, schema, table |
| name, and type criteria are returned. They are ordered by |
| TABLE_TYPE, TABLE_SCHEM, and TABLE_NAME. |
| </p> |
| <p>Each table description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_NAME</b> string => table name |
| </li> |
| <li> |
| <b>TABLE_TYPE</b> string => table type. Typical types are "TABLE", |
| "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", |
| "LOCAL TEMPORARY", "ALIAS", "SYNONYM". |
| </li> |
| <li> |
| <b>REMARKS</b> string => explanatory comment on the table |
| </li> |
| </ol> |
| <p> |
| <b>Note:</b> Some databases may not return information for |
| all tables. |
| </p> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schemaPattern |
| a schema name pattern; "" retrieves those without a schema |
| @param tableNamePattern |
| a table name pattern |
| @param types |
| a list of table types to include |
| @returns |
| each row is a table description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getTables([in]any catalog, [in]string schemaPattern, |
| [in]string tableNamePattern, [in]sequence<string> types) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Gets the schema names available in this database. The results |
| are ordered by schema name. |
| |
| |
| <p>The schema column is: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_SCHEM</b> string => schema name |
| </li> |
| </ol> |
| @returns |
| each row has a single String column that is a schema name |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getSchemas() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets the catalog names available in this database. The results |
| are ordered by catalog name. |
| |
| |
| <p>The catalog column is: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_CAT</b> string => catalog name |
| </li> |
| </ol> |
| @returns |
| each row has a single String column that is a catalog name |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getCatalogs() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets the table types available in this database. The results |
| are ordered by table type. |
| |
| |
| <p>The table type is: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_TYPE</b> string => table type. Typical types are "TABLE", |
| "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", |
| "LOCAL TEMPORARY", "ALIAS", "SYNONYM". |
| </li> |
| </ol> |
| @returns |
| each row has a single String column that is a table type |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getTableTypes() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of table columns available in |
| the specified catalog. |
| |
| |
| <p>Only column descriptions matching the catalog, schema, table |
| and column name criteria are returned. They are ordered by |
| TABLE_SCHEM, TABLE_NAME, and ORDINAL_POSITION. |
| </p> |
| <p>Each column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_NAME</b> string => table name |
| </li> |
| <li> |
| <b>COLUMN_NAME</b> string => column name |
| </li> |
| <li> |
| <b>DATA_TYPE</b> short => SQL type from java.sql.Types |
| </li> |
| <li> |
| <b>TYPE_NAME</b> string => Data source dependent type name, |
| for a UDT the type name is fully qualified |
| </li> |
| <li> |
| <b>COLUMN_SIZE</b> long => column size. For char or date |
| types this is the maximum number of characters, for numeric or |
| decimal types this is precision. |
| </li> |
| <li> |
| <b>BUFFER_LENGTH</b> is not used. |
| </li> |
| <li> |
| <b>DECIMAL_DIGITS</b> long => the number of fractional digits |
| </li> |
| <li> |
| <b>NUM_PREC_RADIX</b> long => Radix (typically either 10 or 2) |
| </li> |
| <li> |
| <b>NULLABLE</b> long => is NULL allowed? |
| <ul> |
| <li> NO_NULLS - might not allow NULL values |
| </li> |
| <li> NULABLE - definitely allows NULL values |
| </li> |
| <li> NULLABLE_UNKNOWN - nullability unknown |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>REMARKS</b> string => comment describing column (may be <NULL/>) |
| </li> |
| <li> |
| <b>COLUMN_DEF</b> string => default value (may be <NULL/>) |
| </li> |
| <li> |
| <b>SQL_DATA_TYPE</b> long => unused |
| </li> |
| <li> |
| <b>SQL_DATETIME_SUB</b> long => unused |
| </li> |
| <li> |
| <b>CHAR_OCTET_LENGTH</b> long => for char types the |
| maximum number of bytes in the column |
| </li> |
| <li> |
| <b>ORDINAL_POSITION</b> int => index of column in table |
| (starting at 1) |
| </li> |
| <li> |
| <b>IS_NULLABLE</b> string => "NO" means column definitely |
| does not allow NULL values; "YES" means the column might |
| allow NULL values. An empty string means nobody knows. |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schemaPattern |
| a schema name pattern; "" retrieves those without a schema |
| @param tableNamePattern |
| a table name pattern |
| @param columnNamePattern |
| a column name pattern |
| @returns |
| each row is a column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getColumns([in]any catalog, [in]string schemaPattern, |
| [in]string tableNamePattern, [in]string columnNamePattern) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of the access rights for a table's columns. |
| |
| |
| <p> |
| Only privileges matching the column name criteria are |
| returned. They are ordered by COLUMN_NAME and PRIVILEGE. |
| </p> |
| <p>Each privilige description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_NAME</b> string => table name |
| </li> |
| <li> |
| <b>COLUMN_NAME</b> string => column name |
| </li> |
| <li> |
| <b>GRANTOR</b> => grantor of access (may be <NULL/>) |
| </li> |
| <li> |
| <b>GRANTEE</b> string => grantee of access |
| </li> |
| <li> |
| <b>PRIVILEGE</b> string => name of access (SELECT, |
| INSERT, UPDATE, REFERENCES, ...) |
| </li> |
| <li> |
| <b>IS_GRANTABLE</b> string => "YES" if grantee is permitted |
| to grant to others; "NO" if not; <NULL/> if unknown |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schema |
| a schema name ; "" retrieves those without a schema |
| @param table |
| a table name |
| @param columnNamePattern |
| a column name pattern |
| @returns |
| each row is a column privilege description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getColumnPrivileges([in]any catalog, [in]string schema, |
| [in]string table, [in]string columnNamePattern) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of the access rights for each table available |
| in a catalog. Note that a table privilege applies to one or |
| more columns in the table. It would be wrong to assume that |
| this priviledge applies to all columns (this may be <TRUE/> for |
| some systems but is not <TRUE/> for all.) |
| |
| |
| <p>Only privileges matching the schema and table name |
| criteria are returned. They are ordered by TABLE_SCHEM, |
| TABLE_NAME, and PRIVILEGE. |
| </p> |
| <p>Each privilige description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_NAME</b> string => table name |
| </li> |
| <li> |
| <b>GRANTOR</b> => grantor of access (may be <NULL/>) |
| </li> |
| <li> |
| <b>GRANTEE</b> string => grantee of access |
| </li> |
| <li> |
| <b>PRIVILEGE</b> string => name of access (SELECT, |
| INSERT, UPDATE, REFERENCES, ...) |
| </li> |
| <li> |
| <b>IS_GRANTABLE</b> string => "YES" if grantee is permitted |
| to grant to others; "NO" if not; <NULL/> if unknown |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schemaPattern |
| a schema name pattern; "" retrieves those without a schema |
| @param tableNamePattern |
| a table name pattern |
| @returns |
| each row is a table privilege description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getTablePrivileges([in]any catalog, [in]string schemaPattern, |
| [in]string tableNamePattern) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of a table's optimal set of columns that |
| uniquely identifies a row. They are ordered by SCOPE. |
| |
| |
| <p>Each column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>SCOPE</b> short => actual scope of result |
| <ul> |
| <li> TEMPORARY - very temporary, while using row |
| </li> |
| <li> TRANSACTION - valid for remainder of current transaction |
| </li> |
| <li> SESSION - valid for remainder of current session |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>COLUMN_NAME</b> string => column name |
| </li> |
| <li> |
| <b>DATA_TYPE</b> short => SQL data type from java.sql.Types |
| </li> |
| <li> |
| <b>TYPE_NAME</b> string => Data source dependent type name, |
| for a UDT the type name is fully qualified |
| </li> |
| <li> |
| <b>COLUMN_SIZE</b> long => precision |
| </li> |
| <li> |
| <b>BUFFER_LENGTH</b> long => not used |
| </li> |
| <li> |
| <b>DECIMAL_DIGITS</b> short => scale |
| </li> |
| <li> |
| <b>PSEUDO_COLUMN</b> short => is this a pseudo column |
| like an Oracle ROWID |
| <ul> |
| <li> UNKNOWN - may or may not be pseudo column |
| </li> |
| <li> NOT_PSEUDO - is NOT a pseudo column |
| </li> |
| <li> PSEUDO - is a pseudo column |
| </li> |
| </ul> |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schema |
| a schema name; "" retrieves those without a schema |
| @param table |
| a table name |
| @param scope |
| the scope of interest; use same values as SCOPE |
| @param nullable |
| include columns that are nullable? |
| @returns |
| each row is a column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getBestRowIdentifier([in]any catalog, [in]string schema, |
| [in]string table, [in]long scope, [in] boolean nullable) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of a table's columns that are automatically |
| updated when any value in a row is updated. They are |
| unordered. |
| |
| |
| <p>Each column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>SCOPE</b> short => is not used |
| </li> |
| <li> |
| <b>COLUMN_NAME</b> string => column name |
| </li> |
| <li> |
| <b>DATA_TYPE</b> short => SQL data type from java.sql.Types |
| </li> |
| <li> |
| <b>TYPE_NAME</b> string => Data source dependent type name |
| </li> |
| <li> |
| <b>COLUMN_SIZE</b> long => precision |
| </li> |
| <li> |
| <b>BUFFER_LENGTH</b> long => length of column value in bytes |
| </li> |
| <li> |
| <b>DECIMAL_DIGITS</b> short => scale |
| </li> |
| <li> |
| <b>PSEUDO_COLUMN</b> short => is this a pseudo column |
| like an Oracle ROWID |
| <ul> |
| <li> UNKNOWN - may or may not be pseudo column |
| </li> |
| <li> NOT_PSEUDO - is NOT a pseudo column |
| </li> |
| <li> PSEUDO - is a pseudo column |
| </li> |
| </ul> |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schema |
| a schema name; "" retrieves those without a schema |
| @param table |
| a table name |
| @returns |
| each row is a column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getVersionColumns([in]any catalog, [in]string schema, |
| [in]string table) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of a table's primary key columns. They |
| are ordered by COLUMN_NAME. |
| |
| |
| <p>Each primary key column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_NAME</b> string => table name |
| </li> |
| <li> |
| <b>COLUMN_NAME</b> string => column name |
| </li> |
| <li> |
| <b>KEY_SEQ</b> short => sequence number within primary key |
| </li> |
| <li> |
| <b>PK_NAME</b> string => primary key name (may be <NULL/>) |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schema |
| a schema name; "" retrieves those without a schema |
| @param table |
| a table name |
| @returns |
| each row is a primary key column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getPrimaryKeys([in]any catalog, [in]string schema, |
| [in]string table) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of the primary key columns that are |
| referenced by a table's foreign key columns (the primary keys |
| imported by a table). They are ordered by PKTABLE_CAT, |
| PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ. |
| |
| |
| <p>Each primary key column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>PKTABLE_CAT</b> string => primary key table catalog |
| being imported (may be <NULL/>) |
| </li> |
| <li> |
| <b>PKTABLE_SCHEM</b> string => primary key table schema |
| being imported (may be <NULL/>) |
| </li> |
| <li> |
| <b>PKTABLE_NAME</b> string => primary key table name |
| being imported |
| </li> |
| <li> |
| <b>PKCOLUMN_NAME</b> string => primary key column name |
| being imported |
| </li> |
| <li> |
| <b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>FKTABLE_NAME</b> string => foreign key table name |
| </li> |
| <li> |
| <b>FKCOLUMN_NAME</b> string => foreign key column name |
| </li> |
| <li> |
| <b>KEY_SEQ</b> short => sequence number within foreign key |
| </li> |
| <li> |
| <b>UPDATE_RULE</b> short => What happens to |
| foreign key when primary is updated: |
| <ul> |
| <li> importedNoAction - do not allow update of primary |
| key if it has been imported |
| </li> |
| <li> importedKeyCascade - change imported key to agree |
| with primary key update |
| </li> |
| <li> importedKeySetNull - change imported key to NULL if |
| its primary key has been updated |
| </li> |
| <li> importedKeySetDefault - change imported key to default values |
| if its primary key has been updated |
| </li> |
| <li> importedKeyRestrict - same as importedKeyNoAction |
| (for ODBC 2.x compatibility) |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>DELETE_RULE</b> short => What happens to |
| the foreign key when primary is deleted. |
| <ul> |
| <li> importedKeyNoAction - do not allow delete of primary |
| key if it has been imported |
| </li> |
| <li> importedKeyCascade - delete rows that import a deleted key |
| </li> |
| <li> importedKeySetNull - change imported key to NULL if |
| its primary key has been deleted |
| </li> |
| <li> importedKeyRestrict - same as importedKeyNoAction |
| (for ODBC 2.x compatibility) |
| </li> |
| <li> importedKeySetDefault - change imported key to default if |
| its primary key has been deleted |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>FK_NAME</b> string => foreign key name (may be <NULL/>) |
| </li> |
| <li> |
| <b>PK_NAME</b> string => primary key name (may be <NULL/>) |
| </li> |
| <li> |
| <b>DEFERRABILITY</b> short => can the evaluation of foreign key |
| constraints be deferred until commit |
| <ul> |
| <li> importedKeyInitiallyDeferred - see SQL92 for definition |
| </li> |
| <li> importedKeyInitiallyImmediate - see SQL92 for definition |
| </li> |
| <li> importedKeyNotDeferrable - see SQL92 for definition |
| </li> |
| </ul> |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schema |
| a schema name; "" retrieves those without a schema |
| @param table |
| a table name |
| @returns |
| each row is a primary key column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getImportedKeys([in]any catalog, [in]string schema, |
| [in]string table) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of the foreign key columns that reference a |
| table's primary key columns (the foreign keys exported by a |
| table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM, |
| FKTABLE_NAME, and KEY_SEQ. |
| |
| |
| <p>Each foreign key column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>PKTABLE_CAT</b> string => primary key table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>PKTABLE_SCHEM</b> string => primary key table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>PKTABLE_NAME</b> string => primary key table name |
| </li> |
| <li> |
| <b>PKCOLUMN_NAME</b> string => primary key column name |
| </li> |
| <li> |
| <b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>) |
| being exported (may be <NULL/>) |
| </li> |
| <li> |
| <b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>) |
| being exported (may be <NULL/>) |
| </li> |
| <li> |
| <b>FKTABLE_NAME</b> string => foreign key table name |
| being exported |
| </li> |
| <li> |
| <b>FKCOLUMN_NAME</b> string => foreign key column name |
| being exported |
| </li> |
| <li> |
| <b>KEY_SEQ</b> short => sequence number within foreign key |
| </li> |
| <li> |
| <b>UPDATE_RULE</b> short => What happens to |
| foreign key when primary is updated: |
| <ul> |
| <li> NO_ACTION - do not allow update of primary |
| key if it has been imported |
| </li> |
| <li> CASCADE - change imported key to agree |
| with primary key update |
| </li> |
| <li> SET_NULL - change imported key to NULL if |
| its primary key has been updated |
| </li> |
| <li> SET_DEFAULT - change imported key to default values |
| if its primary key has been updated |
| </li> |
| <li> RESTRICT - same as importedKeyNoAction |
| (for ODBC 2.x compatibility) |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>DELETE_RULE</b> short => What happens to |
| the foreign key when primary is deleted. |
| <ul> |
| <li> NO_ACTION - do not allow delete of primary |
| key if it has been imported |
| </li> |
| <li> CASCADE - delete rows that import a deleted key |
| </li> |
| <li> SET_NULL - change imported key to NULL if |
| its primary key has been deleted |
| </li> |
| <li> RESTRICT - same as importedKeyNoAction |
| (for ODBC 2.x compatibility) |
| </li> |
| <li> SET_DEFAULT - change imported key to default if |
| its primary key has been deleted |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>FK_NAME</b> string => foreign key name (may be <NULL/>) |
| </li> |
| <li> |
| <b>PK_NAME</b> string => primary key name (may be <NULL/>) |
| </li> |
| <li> |
| <b>DEFERRABILITY</b> short => can the evaluation of foreign key |
| constraints be deferred until commit |
| <ul> |
| <li> INITIALLY_DEFERRED - see SQL92 for definition |
| </li> |
| <li> INITIALLY_IMMEDIATE - see SQL92 for definition |
| </li> |
| <li> NONE - see SQL92 for definition |
| </li> |
| </ul> |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schema |
| a schema name; "" retrieves those without a schema |
| @param table |
| a table name |
| @returns |
| each row is a foreign key column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getExportedKeys([in]any catalog, [in]string schema, |
| [in]string table) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of the foreign key columns in the foreign key |
| table that reference the primary key columns of the primary key |
| table (describe how one table imports another's key.) This |
| should normally return a single foreign key/primary key pair |
| (most tables only import a foreign key from a table once.). They |
| are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and |
| KEY_SEQ. |
| |
| |
| <p>Each foreign key column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>PKTABLE_CAT</b> string => primary key table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>PKTABLE_SCHEM</b> string => primary key table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>PKTABLE_NAME</b> string => primary key table name |
| </li> |
| <li> |
| <b>PKCOLUMN_NAME</b> string => primary key column name |
| </li> |
| <li> |
| <b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>) |
| being exported (may be <NULL/>) |
| </li> |
| <li> |
| <b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>) |
| being exported (may be <NULL/>) |
| </li> |
| <li> |
| <b>FKTABLE_NAME</b> string => foreign key table name |
| being exported |
| </li> |
| <li> |
| <b>FKCOLUMN_NAME</b> string => foreign key column name |
| being exported |
| </li> |
| <li> |
| <b>KEY_SEQ</b> short => sequence number within foreign key |
| </li> |
| <li> |
| <b>UPDATE_RULE</b> short => What happens to |
| foreign key when primary is updated: |
| <ul> |
| <li> NO_ACTION - do not allow update of primary |
| key if it has been imported |
| </li> |
| <li> CASCADE - change imported key to agree |
| with primary key update |
| </li> |
| <li> SET_NULL - change imported key to NULL if |
| its primary key has been updated |
| </li> |
| <li> SET_DEFAULT - change imported key to default values |
| if its primary key has been updated |
| </li> |
| <li> RESTRICT - same as importedKeyNoAction |
| (for ODBC 2.x compatibility) |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>DELETE_RULE</b> short => What happens to |
| the foreign key when primary is deleted. |
| <ul> |
| <li> NO_ACTION - do not allow delete of primary |
| key if it has been imported |
| </li> |
| <li> CASCADE - delete rows that import a deleted key |
| </li> |
| <li> SET_NULL - change imported key to NULL if |
| its primary key has been deleted |
| </li> |
| <li> RESTRICT - same as importedKeyNoAction |
| (for ODBC 2.x compatibility) |
| </li> |
| <li> SET_DEFAULT - change imported key to default if |
| its primary key has been deleted |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>FK_NAME</b> string => foreign key name (may be <NULL/>) |
| </li> |
| <li> |
| <b>PK_NAME</b> string => primary key name (may be <NULL/>) |
| </li> |
| <li> |
| <b>DEFERRABILITY</b> short => can the evaluation of foreign key |
| constraints be deferred until commit |
| <ul> |
| <li> INITIALLY_DEFERRED - see SQL92 for definition |
| </li> |
| <li> INITIALLY_IMMEDIATE - see SQL92 for definition |
| </li> |
| <li> NONE - see SQL92 for definition |
| </li> |
| </ul> |
| </li> |
| </ol> |
| @param primaryCatalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param primarySchema |
| a schema name; "" retrieves those without a schema |
| @param primaryTable |
| the table name that exports the key |
| @param foreignCatalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param foreignSchema |
| a schema name; "" retrieves those without a schema |
| @param foreignTable |
| the table name that imports the key |
| @returns |
| each row is a foreign key column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getCrossReference( |
| [in]any primaryCatalog, [in]string primarySchema, |
| [in]string primaryTable, |
| [in]any foreignCatalog, [in]string foreignSchema, |
| [in]string foreignTable) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of all the standard SQL types supported by |
| this database. They are ordered by DATA_TYPE and then by how |
| closely the data type maps to the corresponding SDBC SQL type. |
| |
| |
| |
| <p>Each type description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TYPE_NAME</b> string => Type name |
| </li> |
| <li> |
| <b>DATA_TYPE</b> short => SQL data type from java.sql.Types |
| </li> |
| <li> |
| <b>PRECISION</b> long => maximum precision |
| </li> |
| <li> |
| <b>LITERAL_PREFIX</b> string => prefix used to quote a literal |
| (may be <NULL/>) |
| </li> |
| <li> |
| <b>LITERAL_SUFFIX</b> string => suffix used to quote a literal |
| (may be <NULL/>) |
| </li> |
| <li> |
| <b>CREATE_PARAMS</b> string => parameters used in creating |
| the type (may be <NULL/>) |
| </li> |
| <li> |
| <b>NULLABLE</b> short => can you use NULL for this type? |
| <ul> |
| <li> NO_NULLS - does not allow NULL values |
| </li> |
| <li> NULLABLE - allows NULL values |
| </li> |
| <li> NULLABLE_UNKNOWN - nullability unknown |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>CASE_SENSITIVE</b> boolean=> is it case sensitive? |
| </li> |
| <li> |
| <b>SEARCHABLE</b> short => can you use "WHERE" based on this type: |
| <ul> |
| <li> NONE - No support |
| </li> |
| <li> CHAR - Only supported with WHERE .. LIKE |
| </li> |
| <li> BASIC - Supported except for WHERE .. LIKE |
| </li> |
| <li> FULL - Supported for all WHERE .. |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>UNSIGNED_ATTRIBUTE</b> boolean => is it unsigned? |
| </li> |
| <li> |
| <b>FIXED_PREC_SCALE</b> boolean => can it be a money value? |
| </li> |
| <li> |
| <b>AUTO_INCREMENT</b> boolean => can it be used for an |
| auto-increment value? |
| </li> |
| <li> |
| <b>LOCAL_TYPE_NAME</b> string => localized version of type name |
| (may be <NULL/>) |
| </li> |
| <li> |
| <b>MINIMUM_SCALE</b> short => minimum scale supported |
| </li> |
| <li> |
| <b>MAXIMUM_SCALE</b> short => maximum scale supported |
| </li> |
| <li> |
| <b>SQL_DATA_TYPE</b> long => unused |
| </li> |
| <li> |
| <b>SQL_DATETIME_SUB</b> long => unused |
| </li> |
| <li> |
| <b>NUM_PREC_RADIX</b> long => usually 2 or 10 |
| </li> |
| </ol> |
| @returns |
| each row is a SQL type description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getTypeInfo() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** gets a description of a table's indices and statistics. They are |
| ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. |
| |
| |
| <p>Each index column description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>TABLE_NAME</b> string => table name |
| </li> |
| <li> |
| <b>NON_UNIQUE</b> boolean => Can index values be non-unique? |
| <FALSE/> when TYPE is tableIndexStatistic |
| </li> |
| <li> |
| <b>INDEX_QUALIFIER</b> string => index catalog (may be <NULL/>); |
| <NULL/> when TYPE is tableIndexStatistic |
| </li> |
| <li> |
| <b>INDEX_NAME</b> string => index name; <NULL/> when TYPE is |
| tableIndexStatistic |
| </li> |
| <li> |
| <b>TYPE</b> short => index type: |
| <ul> |
| <li> 0 - this identifies table statistics that are |
| returned in conjuction with a table's index descriptions |
| </li> |
| <li> CLUSTERED - this is a clustered index |
| </li> |
| <li> HASHED - this is a hashed index |
| </li> |
| <li> OTHER - this is some other style of index |
| </li> |
| </ul> |
| </li> |
| <li> |
| <b>ORDINAL_POSITION</b> short => column sequence number |
| within index; zero when TYPE is tableIndexStatistic |
| </li> |
| <li> |
| <b>COLUMN_NAME</b> string => column name; <NULL/> when TYPE is |
| tableIndexStatistic |
| </li> |
| <li> |
| <b>ASC_OR_DESC</b> string => column sort sequence, "A" => ascending, |
| "D" => descending, may be <NULL/> if sort sequence is not supported; |
| <NULL/> when TYPE is tableIndexStatistic |
| </li> |
| <li> |
| <b>CARDINALITY</b> long => When TYPE is tableIndexStatistic, then |
| this is the number of rows in the table; otherwise, it is the |
| number of unique values in the index. |
| </li> |
| <li> |
| <b>PAGES</b> long => When TYPE is tableIndexStatisic then |
| this is the number of pages used for the table, otherwise it |
| is the number of pages used for the current index. |
| </li> |
| <li> |
| <b>FILTER_CONDITION</b> string => Filter condition, if any. |
| (may be <NULL/>) |
| </li> |
| </ol> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schema |
| a schema name; "" retrieves those without a schema |
| @param table |
| the table name that exports the key |
| @param unique |
| when <TRUE/>, return only indices for unique values; when <FALSE/>, return indices regardless of whether unique or not |
| @param approximate |
| when <TRUE/>, result is allowed to reflect approximate or out of data values; when <FALSE/>, results are requested to be accurate |
| @returns |
| each row is an index column description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getIndexInfo([in]any catalog, [in]string schema, [in]string table, |
| [in]boolean unique, [in]boolean approximate) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database support the given result set type? |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsResultSetType([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Does the database support the concurrency type in combination |
| with the given result set type? |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @param concurrency |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetConcurrency</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsResultSetConcurrency([in]long setType, |
| [in]long concurrency) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether a result set's own updates are visible. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean ownUpdatesAreVisible([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether a result set's own deletes are visible. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean ownDeletesAreVisible([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether a result set's own inserts are visible. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean ownInsertsAreVisible([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether updates made by others are visible. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean othersUpdatesAreVisible([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether deletes made by others are visible. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean othersDeletesAreVisible([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether inserts made by others are visible. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean othersInsertsAreVisible([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether or not a visible row update can be detected by |
| calling the method |
| <code>XResultSet.rowUpdated</code>. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean updatesAreDetected([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether or not a visible row delete can be detected by |
| calling |
| <member scope="com::sun::star::sdbc">XResultSet::rowDeleted()</member> |
| . If deletesAreDetected() |
| returns <FALSE/>, then deleted rows are removed from the result set. |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean deletesAreDetected([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether or not a visible row insert can be detected |
| by calling |
| <member scope="com::sun::star::sdbc">XResultSet::rowInserted().</member> |
| @param setType |
| defined in |
| <type scop="com::sun::star::sdbc">ResultSetType</type> |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean insertsAreDetected([in]long setType) raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** indicates whether the driver supports batch updates. |
| @returns |
| <TRUE/> if so |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| boolean supportsBatchUpdates() raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** Gets a description of the user-defined types defined in a particular |
| schema. Schema-specific UDTs may have type OBJECT, STRUCT, |
| or DISTINCT. |
| |
| |
| <p>Only types matching the catalog, schema, type name, and type |
| criteria are returned. They are ordered by DATA_TYPE, TYPE_SCHEM, |
| and TYPE_NAME. The type name parameter may be a fully-qualified |
| name. In this case, the catalog and schemaPattern parameters are |
| ignored. |
| </p> |
| <p>Each type description has the following columns: |
| </p> |
| <ol> |
| <li> |
| <b>TYPE_CAT</b> string => the type's catalog (may be <NULL/>) |
| </li> |
| <li> |
| <b>TYPE_SCHEM</b> string => type's schema (may be <NULL/>) |
| </li> |
| <li> |
| <b>TYPE_NAME</b> string => type name |
| </li> |
| <li> |
| <b>CLASS_NAME</b> string => Java class name or service name |
| </li> |
| <li> |
| <b>DATA_TYPE</b> string => type value. |
| One of OBJECT, STRUCT, or DISTINCT |
| </li> |
| <li> |
| <b>REMARKS</b> string => explanatory comment on the type |
| </li> |
| </ol> |
| <p> |
| <b>Note:</b> If the driver does not support UDTs, an empty |
| result set is returned. |
| </p> |
| @param catalog |
| a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria |
| @param schemaPattern |
| a schema name pattern; "" retrieves those without a schema |
| @param typeNamePattern |
| a type name pattern; may be a fully-qualified name |
| @param types |
| a list of user-named types to include (OBJECT, STRUCT, or DISTINCT) |
| @returns |
| each row is a type description |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XResultSet getUDTs([in]any catalog, [in]string schemaPattern, |
| [in]string typeNamePattern, [in]sequence<long> types) |
| raises (SQLException); |
| //------------------------------------------------------------------------- |
| |
| /** retrieves the connection that produced this metadata object. |
| @returns |
| the Connection object |
| @throws SQLException |
| if a database access error occurs. |
| */ |
| XConnection getConnection() raises (SQLException); |
| }; |
| |
| //============================================================================= |
| |
| }; }; }; }; |
| |
| /*=========================================================================== |
| ===========================================================================*/ |
| #endif |