package ModSQL; import java.sql.*; /* $Id: DatabaseMetaData.java,v 1.3 2003/05/29 07:19:39 cvs Exp $ * * Copyright (c) 2003 Chris Studholme * * May be copied or modified under the terms of the GNU General Public * License. See COPYING for more information. */ /** * This class provides information about the database as a whole. * *

Many of the methods here return lists of information in ResultSets. * You can use the normal ResultSet methods such as getString and getInt * to retrieve the data from these ResultSets. If a given form of * metadata is not available, these methods should throw a SQLException. * *

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 a null ref, it means * that argument's criteria should be dropped from the search. * *

A SQLException will be thrown if a driver does not support a meta * data method. In the case of methods that return a ResultSet, * either a ResultSet (which may be empty) is returned or a * SQLException is thrown. * * @author chris.studholme@utoronto.ca */ public class DatabaseMetaData implements java.sql.DatabaseMetaData { /** * Default constructor. */ protected DatabaseMetaData() { } //---------------------------------------------------------------------- // First, a variety of minor information about the target database. /** * Can all the procedures returned by getProcedures be called by the * current user? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean allProceduresAreCallable() throws SQLException { return false; } /** * Can all the tables returned by getTable be SELECTed by the * current user? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean allTablesAreSelectable() throws SQLException { return true; } /** * What's the url for this database? * * @return the url or null if it can't be generated * @throws SQLException if a database-access error occurs. */ public String getURL() throws SQLException { return "jdbc:modsql"; } /** * What's our user name as known to the database? * * @return our database user name * @throws SQLException if a database-access error occurs. */ public String getUserName() throws SQLException { return "modsql"; } /** * Is the database in read-only mode? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean isReadOnly() throws SQLException { return false; } /** * Are NULL values sorted high? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean nullsAreSortedHigh() throws SQLException { return true; } /** * Are NULL values sorted low? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean nullsAreSortedLow() throws SQLException { return false; } /** * Are NULL values sorted at the start regardless of sort order? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean nullsAreSortedAtStart() throws SQLException { return false; } /** * Are NULL values sorted at the end regardless of sort order? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean nullsAreSortedAtEnd() throws SQLException { return false; } /** * What's the name of this database product? * * @return database product name * @throws SQLException if a database-access error occurs. */ public String getDatabaseProductName() throws SQLException { return "ModSQL"; } /** * What's the version of this database product? * * @return database version * @throws SQLException if a database-access error occurs. */ public String getDatabaseProductVersion() throws SQLException { return DriverConfig.version; } /** * What's the name of this JDBC driver? * * @return JDBC driver name * @throws SQLException if a database-access error occurs. */ public String getDriverName() throws SQLException { return "ModSQL"; } /** * What's the version of this JDBC driver? * * @return JDBC driver version * @throws SQLException if a database-access error occurs. */ public String getDriverVersion() throws SQLException { return DriverConfig.version; } /** * What's this JDBC driver's major version number? * * @return JDBC driver major version */ public int getDriverMajorVersion() { return DriverConfig.majorVersion; } /** * What's this JDBC driver's minor version number? * * @return JDBC driver minor version number */ public int getDriverMinorVersion() { return DriverConfig.minorVersion; } /** * Does the database store tables in a local file? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean usesLocalFiles() throws SQLException { return true; } /** * Does the database use a file for each table? * * @return true if the database uses a local file for each table * @throws SQLException if a database-access error occurs. */ public boolean usesLocalFilePerTable() throws SQLException { return true; } /** *

Does the database treat mixed case unquoted SQL identifiers as * case sensitive and as a result store them in mixed case? * *

A JDBC-Compliant driver will always return false. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsMixedCaseIdentifiers() throws SQLException { return false; } /** * Does the database treat mixed case unquoted SQL identifiers as * case insensitive and store them in upper case? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean storesUpperCaseIdentifiers() throws SQLException { return false; } /** * Does the database treat mixed case unquoted SQL identifiers as * case insensitive and store them in lower case? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean storesLowerCaseIdentifiers() throws SQLException { return true; } /** * Does the database treat mixed case unquoted SQL identifiers as * case insensitive and store them in mixed case? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean storesMixedCaseIdentifiers() throws SQLException { return false; } /** * Does the database treat mixed case quoted SQL identifiers as * case sensitive and as a result store them in mixed case? * * A JDBC-Compliant driver will always return true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException { return true; } /** * Does the database treat mixed case quoted SQL identifiers as * case insensitive and store them in upper case? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean storesUpperCaseQuotedIdentifiers() throws SQLException { return false; } /** * Does the database treat mixed case quoted SQL identifiers as * case insensitive and store them in lower case? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean storesLowerCaseQuotedIdentifiers() throws SQLException { return false; } /** * Does the database treat mixed case quoted SQL identifiers as * case insensitive and store them in mixed case? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean storesMixedCaseQuotedIdentifiers() throws SQLException { return true; } /** * What's the string used to quote SQL identifiers? * This returns a space " " if identifier quoting isn't supported. * * A JDBC-Compliant driver always uses a double quote character. * * @return the quoting string * @throws SQLException if a database-access error occurs. */ public String getIdentifierQuoteString() throws SQLException { return " "; } /** * Get a comma separated list of all a database's SQL keywords * that are NOT also SQL92 keywords. * * @return the list * @throws SQLException if a database-access error occurs. */ public String getSQLKeywords() throws SQLException { throw new SQLException("not implemented"); } /** * Get a comma separated list of math functions. * * @return the list * @throws SQLException if a database-access error occurs. */ public String getNumericFunctions() throws SQLException { throw new SQLException("not implemented"); } /** * Get a comma separated list of string functions. * * @return the list * @throws SQLException if a database-access error occurs. */ public String getStringFunctions() throws SQLException { throw new SQLException("not implemented"); } /** * Get a comma separated list of system functions. * * @return the list * @throws SQLException if a database-access error occurs. */ public String getSystemFunctions() throws SQLException { throw new SQLException("not implemented"); } /** * Get a comma separated list of time and date functions. * * @return the list * @throws SQLException if a database-access error occurs. */ public String getTimeDateFunctions() throws SQLException { throw new SQLException("not implemented"); } /** * This is the string that can be used to escape '_' or '%' in * the string pattern style catalog search parameters. * *

The '_' character represents any single character. *

The '%' character represents any sequence of zero or * more characters. * * @return the string used to escape wildcard characters * @throws SQLException if a database-access error occurs. */ public String getSearchStringEscape() throws SQLException { return "\\"; } /** * Get all the "extra" characters that can be used in unquoted * identifier names (those beyond a-z, A-Z, 0-9 and _). * * @return the string containing the extra characters * @throws SQLException if a database-access error occurs. */ public String getExtraNameCharacters() throws SQLException { return ""; } //-------------------------------------------------------------------- // Functions describing which features are supported. /** * Is "ALTER TABLE" with add column supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsAlterTableWithAddColumn() throws SQLException { return false; } /** * Is "ALTER TABLE" with drop column supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsAlterTableWithDropColumn() throws SQLException { return false; } /** * Is column aliasing supported? * *

If so, the SQL AS clause can be used to provide names for * computed columns or to provide alias names for columns as * required. * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsColumnAliasing() throws SQLException { return true; } /** * Are concatenations between NULL and non-NULL values NULL? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean nullPlusNonNullIsNull() throws SQLException { return true; } /** * Is the CONVERT function between SQL types supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsConvert() throws SQLException { return false; } /** * Is CONVERT between the given SQL types supported? * * @param fromType the type to convert from * @param toType the type to convert to * @return true if so * @throws SQLException if a database-access error occurs. * @see Types */ public boolean supportsConvert(int fromType, int toType) throws SQLException { return false; } /** * Are table correlation names supported? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsTableCorrelationNames() throws SQLException { return true; } /** * If table correlation names are supported, are they restricted * to be different from the names of the tables? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsDifferentTableCorrelationNames() throws SQLException { return false; } /** * Are expressions in "ORDER BY" lists supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsExpressionsInOrderBy() throws SQLException { return true; } /** * Can an "ORDER BY" clause use columns not in the SELECT? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsOrderByUnrelated() throws SQLException { return true; } /** * Is some form of "GROUP BY" clause supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsGroupBy() throws SQLException { return true; } /** * Can a "GROUP BY" clause use columns not in the SELECT? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsGroupByUnrelated() throws SQLException { return true; } /** * Can a "GROUP BY" clause add columns not in the SELECT * provided it specifies all the columns in the SELECT? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsGroupByBeyondSelect() throws SQLException { return true; } /** * Is the escape character in "LIKE" clauses supported? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsLikeEscapeClause() throws SQLException { return false; } /** * Are multiple ResultSets from a single execute supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsMultipleResultSets() throws SQLException { return false; } /** * Can we have multiple transactions open at once (on different * connections)? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsMultipleTransactions() throws SQLException { return true; } /** * Can columns be defined as non-nullable? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsNonNullableColumns() throws SQLException { return false; } /** * Is the ODBC Minimum SQL grammar supported? * * All JDBC-Compliant drivers must return true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsMinimumSQLGrammar() throws SQLException { return false; } /** * Is the ODBC Core SQL grammar supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsCoreSQLGrammar() throws SQLException { return false; } /** * Is the ODBC Extended SQL grammar supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsExtendedSQLGrammar() throws SQLException { return false; } /** * Is the ANSI92 entry level SQL grammar supported? * * All JDBC-Compliant drivers must return true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsANSI92EntryLevelSQL() throws SQLException { return false; } /** * Is the ANSI92 intermediate SQL grammar supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsANSI92IntermediateSQL() throws SQLException { return false; } /** * Is the ANSI92 full SQL grammar supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsANSI92FullSQL() throws SQLException { return false; } /** * Is the SQL Integrity Enhancement Facility supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsIntegrityEnhancementFacility() throws SQLException { return false; } /** * Is some form of outer join supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsOuterJoins() throws SQLException { return true; } /** * Are full nested outer joins supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsFullOuterJoins() throws SQLException { return true; } /** * Is there limited support for outer joins? (This will be true * if supportFullOuterJoins is true.) * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsLimitedOuterJoins() throws SQLException { return true; } /** * What's the database vendor's preferred term for "schema"? * * @return the vendor term * @throws SQLException if a database-access error occurs. */ public String getSchemaTerm() throws SQLException { return "schema"; } /** * What's the database vendor's preferred term for "procedure"? * * @return the vendor term * @throws SQLException if a database-access error occurs. */ public String getProcedureTerm() throws SQLException { return "procedure"; } /** * What's the database vendor's preferred term for "catalog"? * * @return the vendor term * @throws SQLException if a database-access error occurs. */ public String getCatalogTerm() throws SQLException { return "catalog"; } /** * Does a catalog appear at the start of a qualified table name? * (Otherwise it appears at the end) * * @return true if it appears at the start * @throws SQLException if a database-access error occurs. */ public boolean isCatalogAtStart() throws SQLException { return true; } /** * What's the separator between catalog and table name? * * @return the separator string * @throws SQLException if a database-access error occurs. */ public String getCatalogSeparator() throws SQLException { return "."; } /** * Can a schema name be used in a data manipulation statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSchemasInDataManipulation() throws SQLException { return false; } /** * Can a schema name be used in a procedure call statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSchemasInProcedureCalls() throws SQLException { return false; } /** * Can a schema name be used in a table definition statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSchemasInTableDefinitions() throws SQLException { return false; } /** * Can a schema name be used in an index definition statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSchemasInIndexDefinitions() throws SQLException { return false; } /** * Can a schema name be used in a privilege definition statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException { return false; } /** * Can a catalog name be used in a data manipulation statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsCatalogsInDataManipulation() throws SQLException { return false; } /** * Can a catalog name be used in a procedure call statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsCatalogsInProcedureCalls() throws SQLException { return false; } /** * Can a catalog name be used in a table definition statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsCatalogsInTableDefinitions() throws SQLException { return true; } /** * Can a catalog name be used in an index definition statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsCatalogsInIndexDefinitions() throws SQLException { return true; } /** * Can a catalog name be used in a privilege definition statement? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException { return false; } /** * Is positioned DELETE supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsPositionedDelete() throws SQLException { return false; } /** * Is positioned UPDATE supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsPositionedUpdate() throws SQLException { return false; } /** * Is SELECT for UPDATE supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSelectForUpdate() throws SQLException { return false; } /** * Are stored procedure calls using the stored procedure escape * syntax supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsStoredProcedures() throws SQLException { return false; } /** * Are subqueries in comparison expressions supported? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSubqueriesInComparisons() throws SQLException { return true; } /** * Are subqueries in 'exists' expressions supported? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSubqueriesInExists() throws SQLException { return true; } /** * Are subqueries in 'in' statements supported? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSubqueriesInIns() throws SQLException { return true; } /** * Are subqueries in quantified expressions supported? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsSubqueriesInQuantifieds() throws SQLException { return true; } /** * Are correlated subqueries supported? * * A JDBC-Compliant driver always returns true. * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsCorrelatedSubqueries() throws SQLException { return true; } /** * Is SQL UNION supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsUnion() throws SQLException { return false; } /** * Is SQL UNION ALL supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsUnionAll() throws SQLException { return false; } /** * Can cursors remain open across commits? * * @return true if cursors always remain open; false if they might not remain open * @throws SQLException if a database-access error occurs. */ public boolean supportsOpenCursorsAcrossCommit() throws SQLException { return false; } /** * Can cursors remain open across rollbacks? * * @return true if cursors always remain open; false if they might not remain open * @throws SQLException if a database-access error occurs. */ public boolean supportsOpenCursorsAcrossRollback() throws SQLException { return false; } /** * Can statements remain open across commits? * * @return true if statements always remain open; false if they might not remain open * @throws SQLException if a database-access error occurs. */ public boolean supportsOpenStatementsAcrossCommit() throws SQLException { return false; } /** * Can statements remain open across rollbacks? * * @return true if statements always remain open; false if they might not remain open * @throws SQLException if a database-access error occurs. */ public boolean supportsOpenStatementsAcrossRollback() throws SQLException { return false; } //---------------------------------------------------------------------- // The following group of methods exposes various limitations // based on the target database with the current driver. // Unless otherwise specified, a result of zero means there is no // limit, or the limit is not known. /** * How many hex characters can you have in an inline binary literal? * * @return max literal length * @throws SQLException if a database-access error occurs. */ public int getMaxBinaryLiteralLength() throws SQLException { return 0; } /** * What's the max length for a character literal? * * @return max literal length * @throws SQLException if a database-access error occurs. */ public int getMaxCharLiteralLength() throws SQLException { return 0; } /** * What's the limit on column name length? * * @return max literal length * @throws SQLException if a database-access error occurs. */ public int getMaxColumnNameLength() throws SQLException { return 0; } /** * What's the maximum number of columns in a "GROUP BY" clause? * * @return max number of columns * @throws SQLException if a database-access error occurs. */ public int getMaxColumnsInGroupBy() throws SQLException { return 0; } /** * What's the maximum number of columns allowed in an index? * * @return max columns * @throws SQLException if a database-access error occurs. */ public int getMaxColumnsInIndex() throws SQLException { return 1; } /** * What's the maximum number of columns in an "ORDER BY" clause? * * @return max columns * @throws SQLException if a database-access error occurs. */ public int getMaxColumnsInOrderBy() throws SQLException { return 0; } /** * What's the maximum number of columns in a "SELECT" list? * * @return max columns * @throws SQLException if a database-access error occurs. */ public int getMaxColumnsInSelect() throws SQLException { return 0; } /** * What's the maximum number of columns in a table? * * @return max columns * @throws SQLException if a database-access error occurs. */ public int getMaxColumnsInTable() throws SQLException { return 0; } /** * How many active connections can we have at a time to this database? * * @return max connections * @throws SQLException if a database-access error occurs. */ public int getMaxConnections() throws SQLException { return 0; } /** * What's the maximum cursor name length? * * @return max cursor name length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxCursorNameLength() throws SQLException { return 0; } /** * What's the maximum length of an index (in bytes)? * * @return max index length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxIndexLength() throws SQLException { return 0; } /** * What's the maximum length allowed for a schema name? * * @return max name length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxSchemaNameLength() throws SQLException { return 0; } /** * What's the maximum length of a procedure name? * * @return max name length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxProcedureNameLength() throws SQLException { return 0; } /** * What's the maximum length of a catalog name? * * @return max name length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxCatalogNameLength() throws SQLException { return 0; } /** * What's the maximum length of a single row? * * @return max row size in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxRowSize() throws SQLException { return 0; } /** * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY * blobs? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean doesMaxRowSizeIncludeBlobs() throws SQLException { return true; } /** * What's the maximum length of a SQL statement? * * @return max length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxStatementLength() throws SQLException { return 0; } /** * How many active statements can we have open at one time to this * database? * * @return the maximum * @throws SQLException if a database-access error occurs. */ public int getMaxStatements() throws SQLException { return 0; } /** * What's the maximum length of a table name? * * @return max name length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxTableNameLength() throws SQLException { return 0; } /** * What's the maximum number of tables in a SELECT? * * @return the maximum * @throws SQLException if a database-access error occurs. */ public int getMaxTablesInSelect() throws SQLException { return 0; } /** * What's the maximum length of a user name? * * @return max name length in bytes * @throws SQLException if a database-access error occurs. */ public int getMaxUserNameLength() throws SQLException { return 0; } //---------------------------------------------------------------------- /** * What's the database's default transaction isolation level? The * values are defined in java.sql.Connection. * * @return the default isolation level * @throws SQLException if a database-access error occurs. * @see Connection */ public int getDefaultTransactionIsolation() throws SQLException { return Connection.TRANSACTION_NONE; } /** * Are transactions supported? If not, commit is a noop and the * isolation level is TRANSACTION_NONE. * * @return true if transactions are supported * @throws SQLException if a database-access error occurs. */ public boolean supportsTransactions() throws SQLException { return false; } /** * Does the database support the given transaction isolation level? * * @param level the values are defined in java.sql.Connection * @return true if so * @throws SQLException if a database-access error occurs. * @see Connection */ public boolean supportsTransactionIsolationLevel(int level) throws SQLException { return (level==Connection.TRANSACTION_NONE); } /** * Are both data definition and data manipulation statements * within a transaction supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException { return false; } /** * Are only data manipulation statements within a transaction * supported? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean supportsDataManipulationTransactionsOnly() throws SQLException { return true; } /** * Does a data definition statement within a transaction force the * transaction to commit? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean dataDefinitionCausesTransactionCommit() throws SQLException { return false; } /** * Is a data definition statement within a transaction ignored? * * @return true if so * @throws SQLException if a database-access error occurs. */ public boolean dataDefinitionIgnoredInTransactions() throws SQLException { return false; } /** * Get a description of stored procedures available in a * catalog. * *

Only procedure descriptions matching the schema and * procedure name criteria are returned. They are ordered by * PROCEDURE_SCHEM, and PROCEDURE_NAME. * *

Each procedure description has the the following columns: *

    *
  1. PROCEDURE_CAT String => procedure catalog (may be null) *
  2. PROCEDURE_SCHEM String => procedure schema (may be null) *
  3. PROCEDURE_NAME String => procedure name *
  4. reserved for future use *
  5. reserved for future use *
  6. reserved for future use *
  7. REMARKS String => explanatory comment on the procedure *
  8. PROCEDURE_TYPE short => kind of procedure: *
      *
    • procedureResultUnknown - May return a result *
    • procedureNoResult - Does not return a result *
    • procedureReturnsResult - Returns a result *
    *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null 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 * @return ResultSet - each row is a procedure description * @throws SQLException if a database-access error occurs. * @see #getSearchStringEscape */ public java.sql.ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException { return null; } /** * Get a description of a catalog's stored procedure parameters * and result columns. * *

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. * *

Each row in the ResultSet is a parameter description or * column description with the following fields: *

    *
  1. PROCEDURE_CAT String => procedure catalog (may be null) *
  2. PROCEDURE_SCHEM String => procedure schema (may be null) *
  3. PROCEDURE_NAME String => procedure name *
  4. COLUMN_NAME String => column/parameter name *
  5. COLUMN_TYPE Short => kind of column/parameter: *
      *
    • procedureColumnUnknown - nobody knows *
    • procedureColumnIn - IN parameter *
    • procedureColumnInOut - INOUT parameter *
    • procedureColumnOut - OUT parameter *
    • procedureColumnReturn - procedure return value *
    • procedureColumnResult - result column in ResultSet *
    *
  6. DATA_TYPE short => SQL type from java.sql.Types *
  7. TYPE_NAME String => SQL type name *
  8. PRECISION int => precision *
  9. LENGTH int => length in bytes of data *
  10. SCALE short => scale *
  11. RADIX short => radix *
  12. NULLABLE short => can it contain NULL? *
      *
    • procedureNoNulls - does not allow NULL values *
    • procedureNullable - allows NULL values *
    • procedureNullableUnknown - nullability unknown *
    *
  13. REMARKS String => comment describing parameter/column *
* *

Note: Some databases may not return the column * descriptions for a procedure. Additional columns beyond * REMARKS can be defined by the database. * * @param catalog a catalog name; "" retrieves those without a * catalog; null 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 * @return ResultSet - each row is a stored procedure parameter or * column description * @throws SQLException if a database-access error occurs. * @see #getSearchStringEscape */ public java.sql.ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException { return null; } /** * Get a description of tables available in a catalog. * *

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. * *

Each table description has the following columns: *

    *
  1. TABLE_CAT String => table catalog (may be null) *
  2. TABLE_SCHEM String => table schema (may be null) *
  3. TABLE_NAME String => table name *
  4. TABLE_TYPE String => table type. Typical types are "TABLE", * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". *
  5. REMARKS String => explanatory comment on the table *
* *

Note: Some databases may not return information for * all tables. * * @param catalog a catalog name; "" retrieves those without a * catalog; null 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; null returns all types * @return ResultSet - each row is a table description * @throws SQLException if a database-access error occurs. * @see #getSearchStringEscape */ public java.sql.ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException { return null; } /** * Get the schema names available in this database. The results * are ordered by schema name. * *

The schema column is: *

    *
  1. TABLE_SCHEM String => schema name *
* * @return ResultSet - each row has a single String column that is a * schema name * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getSchemas() throws SQLException { return null; } /** * Get the catalog names available in this database. The results * are ordered by catalog name. * *

The catalog column is: *

    *
  1. TABLE_CAT String => catalog name *
* * @return ResultSet - each row has a single String column that is a * catalog name * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getCatalogs() throws SQLException { return null; } /** * Get the table types available in this database. The results * are ordered by table type. * *

The table type is: *

    *
  1. TABLE_TYPE String => table type. Typical types are "TABLE", * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". *
* * @return ResultSet - each row has a single String column that is a * table type * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getTableTypes() throws SQLException { return null; } /** * Get a description of table columns available in a catalog. * *

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. * *

Each column description has the following columns: *

    *
  1. TABLE_CAT String => table catalog (may be null) *
  2. TABLE_SCHEM String => table schema (may be null) *
  3. TABLE_NAME String => table name *
  4. COLUMN_NAME String => column name *
  5. DATA_TYPE short => SQL type from java.sql.Types *
  6. TYPE_NAME String => Data source dependent type name *
  7. COLUMN_SIZE int => column size. For char or date * types this is the maximum number of characters, for numeric or * decimal types this is precision. *
  8. BUFFER_LENGTH is not used. *
  9. DECIMAL_DIGITS int => the number of fractional digits *
  10. NUM_PREC_RADIX int => Radix (typically either 10 or 2) *
  11. NULLABLE int => is NULL allowed? *
      *
    • columnNoNulls - might not allow NULL values *
    • columnNullable - definitely allows NULL values *
    • columnNullableUnknown - nullability unknown *
    *
  12. REMARKS String => comment describing column (may be null) *
  13. COLUMN_DEF String => default value (may be null) *
  14. SQL_DATA_TYPE int => unused *
  15. SQL_DATETIME_SUB int => unused *
  16. CHAR_OCTET_LENGTH int => for char types the * maximum number of bytes in the column *
  17. ORDINAL_POSITION int => index of column in table * (starting at 1) *
  18. IS_NULLABLE String => "NO" means column definitely * does not allow NULL values; "YES" means the column might * allow NULL values. An empty string means nobody knows. *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null 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 * @return ResultSet - each row is a column description * @throws SQLException if a database-access error occurs. * @see #getSearchStringEscape */ public java.sql.ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException { return null; } /** * Get a description of the access rights for a table's columns. * *

Only privileges matching the column name criteria are * returned. They are ordered by COLUMN_NAME and PRIVILEGE. * *

Each privilige description has the following columns: *

    *
  1. TABLE_CAT String => table catalog (may be null) *
  2. TABLE_SCHEM String => table schema (may be null) *
  3. TABLE_NAME String => table name *
  4. COLUMN_NAME String => column name *
  5. GRANTOR => grantor of access (may be null) *
  6. GRANTEE String => grantee of access *
  7. PRIVILEGE String => name of access (SELECT, * INSERT, UPDATE, REFRENCES, ...) *
  8. IS_GRANTABLE String => "YES" if grantee is permitted * to grant to others; "NO" if not; null if unknown *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null 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 * @return ResultSet - each row is a column privilege description * @throws SQLException if a database-access error occurs. * @see #getSearchStringEscape */ public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern) throws SQLException { return null; } /** * Get 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.) * *

Only privileges matching the schema and table name * criteria are returned. They are ordered by TABLE_SCHEM, * TABLE_NAME, and PRIVILEGE. * *

Each privilige description has the following columns: *

    *
  1. TABLE_CAT String => table catalog (may be null) *
  2. TABLE_SCHEM String => table schema (may be null) *
  3. TABLE_NAME String => table name *
  4. GRANTOR => grantor of access (may be null) *
  5. GRANTEE String => grantee of access *
  6. PRIVILEGE String => name of access (SELECT, * INSERT, UPDATE, REFRENCES, ...) *
  7. IS_GRANTABLE String => "YES" if grantee is permitted * to grant to others; "NO" if not; null if unknown *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null 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 * @return ResultSet - each row is a table privilege description * @throws SQLException if a database-access error occurs. * @see #getSearchStringEscape */ public java.sql.ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException { return null; } /** * Get a description of a table's optimal set of columns that * uniquely identifies a row. They are ordered by SCOPE. * *

Each column description has the following columns: *

    *
  1. SCOPE short => actual scope of result *
      *
    • bestRowTemporary - very temporary, while using row *
    • bestRowTransaction - valid for remainder of current transaction *
    • bestRowSession - valid for remainder of current session *
    *
  2. COLUMN_NAME String => column name *
  3. DATA_TYPE short => SQL data type from java.sql.Types *
  4. TYPE_NAME String => Data source dependent type name *
  5. COLUMN_SIZE int => precision *
  6. BUFFER_LENGTH int => not used *
  7. DECIMAL_DIGITS short => scale *
  8. PSEUDO_COLUMN short => is this a pseudo column * like an Oracle ROWID *
      *
    • bestRowUnknown - may or may not be pseudo column *
    • bestRowNotPseudo - is NOT a pseudo column *
    • bestRowPseudo - is a pseudo column *
    *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null 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? * @return ResultSet - each row is a column description * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException { return null; } /** * Get a description of a table's columns that are automatically * updated when any value in a row is updated. They are * unordered. * *

Each column description has the following columns: *

    *
  1. SCOPE short => is not used *
  2. COLUMN_NAME String => column name *
  3. DATA_TYPE short => SQL data type from java.sql.Types *
  4. TYPE_NAME String => Data source dependent type name *
  5. COLUMN_SIZE int => precision *
  6. BUFFER_LENGTH int => length of column value in bytes *
  7. DECIMAL_DIGITS short => scale *
  8. PSEUDO_COLUMN short => is this a pseudo column * like an Oracle ROWID *
      *
    • versionColumnUnknown - may or may not be pseudo column *
    • versionColumnNotPseudo - is NOT a pseudo column *
    • versionColumnPseudo - is a pseudo column *
    *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param schema a schema name; "" retrieves those without a schema * @param table a table name * @return ResultSet - each row is a column description * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException { return null; } /** * Get a description of a table's primary key columns. They * are ordered by COLUMN_NAME. * *

Each primary key column description has the following columns: *

    *
  1. TABLE_CAT String => table catalog (may be null) *
  2. TABLE_SCHEM String => table schema (may be null) *
  3. TABLE_NAME String => table name *
  4. COLUMN_NAME String => column name *
  5. KEY_SEQ short => sequence number within primary key *
  6. PK_NAME String => primary key name (may be null) *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param schema a schema name pattern; "" retrieves those * without a schema * @param table a table name * @return ResultSet - each row is a primary key column description * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException { return null; } /** * Get 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. * *

Each primary key column description has the following columns: *

    *
  1. PKTABLE_CAT String => primary key table catalog * being imported (may be null) *
  2. PKTABLE_SCHEM String => primary key table schema * being imported (may be null) *
  3. PKTABLE_NAME String => primary key table name * being imported *
  4. PKCOLUMN_NAME String => primary key column name * being imported *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) *
  7. FKTABLE_NAME String => foreign key table name *
  8. FKCOLUMN_NAME String => foreign key column name *
  9. KEY_SEQ short => sequence number within foreign key *
  10. UPDATE_RULE short => What happens to * foreign key when primary is updated: *
      *
    • importedNoAction - do not allow update of primary * key if it has been imported *
    • importedKeyCascade - change imported key to agree * with primary key update *
    • importedKeySetNull - change imported key to NULL if * its primary key has been updated *
    • importedKeySetDefault - change imported key to default values * if its primary key has been updated *
    • importedKeyRestrict - same as importedKeyNoAction * (for ODBC 2.x compatibility) *
    *
  11. DELETE_RULE short => What happens to * the foreign key when primary is deleted. *
      *
    • importedKeyNoAction - do not allow delete of primary * key if it has been imported *
    • importedKeyCascade - delete rows that import a deleted key *
    • importedKeySetNull - change imported key to NULL if * its primary key has been deleted *
    • importedKeyRestrict - same as importedKeyNoAction * (for ODBC 2.x compatibility) *
    • importedKeySetDefault - change imported key to default if * its primary key has been deleted *
    *
  12. FK_NAME String => foreign key name (may be null) *
  13. PK_NAME String => primary key name (may be null) *
  14. DEFERRABILITY short => can the evaluation of foreign key * constraints be deferred until commit *
      *
    • importedKeyInitiallyDeferred - see SQL92 for definition *
    • importedKeyInitiallyImmediate - see SQL92 for definition *
    • importedKeyNotDeferrable - see SQL92 for definition *
    *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param schema a schema name pattern; "" retrieves those * without a schema * @param table a table name * @return ResultSet - each row is a primary key column description * @throws SQLException if a database-access error occurs. * @see #getExportedKeys */ public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException { return null; } /** * Get 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. * *

Each foreign key column description has the following columns: *

    *
  1. PKTABLE_CAT String => primary key table catalog (may be null) *
  2. PKTABLE_SCHEM String => primary key table schema (may be null) *
  3. PKTABLE_NAME String => primary key table name *
  4. PKCOLUMN_NAME String => primary key column name *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) * being exported (may be null) *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) * being exported (may be null) *
  7. FKTABLE_NAME String => foreign key table name * being exported *
  8. FKCOLUMN_NAME String => foreign key column name * being exported *
  9. KEY_SEQ short => sequence number within foreign key *
  10. UPDATE_RULE short => What happens to * foreign key when primary is updated: *
      *
    • importedNoAction - do not allow update of primary * key if it has been imported *
    • importedKeyCascade - change imported key to agree * with primary key update *
    • importedKeySetNull - change imported key to NULL if * its primary key has been updated *
    • importedKeySetDefault - change imported key to default values * if its primary key has been updated *
    • importedKeyRestrict - same as importedKeyNoAction * (for ODBC 2.x compatibility) *
    *
  11. DELETE_RULE short => What happens to * the foreign key when primary is deleted. *
      *
    • importedKeyNoAction - do not allow delete of primary * key if it has been imported *
    • importedKeyCascade - delete rows that import a deleted key *
    • importedKeySetNull - change imported key to NULL if * its primary key has been deleted *
    • importedKeyRestrict - same as importedKeyNoAction * (for ODBC 2.x compatibility) *
    • importedKeySetDefault - change imported key to default if * its primary key has been deleted *
    *
  12. FK_NAME String => foreign key name (may be null) *
  13. PK_NAME String => primary key name (may be null) *
  14. DEFERRABILITY short => can the evaluation of foreign key * constraints be deferred until commit *
      *
    • importedKeyInitiallyDeferred - see SQL92 for definition *
    • importedKeyInitiallyImmediate - see SQL92 for definition *
    • importedKeyNotDeferrable - see SQL92 for definition *
    *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param schema a schema name pattern; "" retrieves those * without a schema * @param table a table name * @return ResultSet - each row is a foreign key column description * @throws SQLException if a database-access error occurs. * @see #getImportedKeys */ public java.sql.ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException { return null; } /** * Get 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. * *

Each foreign key column description has the following columns: *

    *
  1. PKTABLE_CAT String => primary key table catalog (may be null) *
  2. PKTABLE_SCHEM String => primary key table schema (may be null) *
  3. PKTABLE_NAME String => primary key table name *
  4. PKCOLUMN_NAME String => primary key column name *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) * being exported (may be null) *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) * being exported (may be null) *
  7. FKTABLE_NAME String => foreign key table name * being exported *
  8. FKCOLUMN_NAME String => foreign key column name * being exported *
  9. KEY_SEQ short => sequence number within foreign key *
  10. UPDATE_RULE short => What happens to * foreign key when primary is updated: *
      *
    • importedNoAction - do not allow update of primary * key if it has been imported *
    • importedKeyCascade - change imported key to agree * with primary key update *
    • importedKeySetNull - change imported key to NULL if * its primary key has been updated *
    • importedKeySetDefault - change imported key to default values * if its primary key has been updated *
    • importedKeyRestrict - same as importedKeyNoAction * (for ODBC 2.x compatibility) *
    *
  11. DELETE_RULE short => What happens to * the foreign key when primary is deleted. *
      *
    • importedKeyNoAction - do not allow delete of primary * key if it has been imported *
    • importedKeyCascade - delete rows that import a deleted key *
    • importedKeySetNull - change imported key to NULL if * its primary key has been deleted *
    • importedKeyRestrict - same as importedKeyNoAction * (for ODBC 2.x compatibility) *
    • importedKeySetDefault - change imported key to default if * its primary key has been deleted *
    *
  12. FK_NAME String => foreign key name (may be null) *
  13. PK_NAME String => primary key name (may be null) *
  14. DEFERRABILITY short => can the evaluation of foreign key * constraints be deferred until commit *
      *
    • importedKeyInitiallyDeferred - see SQL92 for definition *
    • importedKeyInitiallyImmediate - see SQL92 for definition *
    • importedKeyNotDeferrable - see SQL92 for definition *
    *
* * @param primaryCatalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param primarySchema a schema name pattern; "" retrieves those * without a schema * @param primaryTable the table name that exports the key * @param foreignCatalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param foreignSchema a schema name pattern; "" retrieves those * without a schema * @param foreignTable the table name that imports the key * @return ResultSet - each row is a foreign key column description * @throws SQLException if a database-access error occurs. * @see #getImportedKeys */ public java.sql.ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException { return null; } /** * Get 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 JDBC SQL type. * *

Each type description has the following columns: *

    *
  1. TYPE_NAME String => Type name *
  2. DATA_TYPE short => SQL data type from java.sql.Types *
  3. PRECISION int => maximum precision *
  4. LITERAL_PREFIX String => prefix used to quote a literal * (may be null) *
  5. LITERAL_SUFFIX String => suffix used to quote a literal (may be null) *
  6. CREATE_PARAMS String => parameters used in creating * the type (may be null) *
  7. NULLABLE short => can you use NULL for this type? *
      *
    • typeNoNulls - does not allow NULL values *
    • typeNullable - allows NULL values *
    • typeNullableUnknown - nullability unknown *
    *
  8. CASE_SENSITIVE boolean=> is it case sensitive? *
  9. SEARCHABLE short => can you use "WHERE" based on this type: *
      *
    • typePredNone - No support *
    • typePredChar - Only supported with WHERE .. LIKE *
    • typePredBasic - Supported except for WHERE .. LIKE *
    • typeSearchable - Supported for all WHERE .. *
    *
  10. UNSIGNED_ATTRIBUTE boolean => is it unsigned? *
  11. FIXED_PREC_SCALE boolean => can it be a money value? *
  12. AUTO_INCREMENT boolean => can it be used for an * auto-increment value? *
  13. LOCAL_TYPE_NAME String => localized version of type name * (may be null) *
  14. MINIMUM_SCALE short => minimum scale supported *
  15. MAXIMUM_SCALE short => maximum scale supported *
  16. SQL_DATA_TYPE int => unused *
  17. SQL_DATETIME_SUB int => unused *
  18. NUM_PREC_RADIX int => usually 2 or 10 *
* * @return ResultSet - each row is a SQL type description * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getTypeInfo() throws SQLException { return null; } /** * Get a description of a table's indices and statistics. They are * ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. * *

Each index column description has the following columns: *

    *
  1. TABLE_CAT String => table catalog (may be null) *
  2. TABLE_SCHEM String => table schema (may be null) *
  3. TABLE_NAME String => table name *
  4. NON_UNIQUE boolean => Can index values be non-unique? * false when TYPE is tableIndexStatistic *
  5. INDEX_QUALIFIER String => index catalog (may be null); * null when TYPE is tableIndexStatistic *
  6. INDEX_NAME String => index name; null when TYPE is * tableIndexStatistic *
  7. TYPE short => index type: *
      *
    • tableIndexStatistic - this identifies table statistics that are * returned in conjuction with a table's index descriptions *
    • tableIndexClustered - this is a clustered index *
    • tableIndexHashed - this is a hashed index *
    • tableIndexOther - this is some other style of index *
    *
  8. ORDINAL_POSITION short => column sequence number * within index; zero when TYPE is tableIndexStatistic *
  9. COLUMN_NAME String => column name; null when TYPE is * tableIndexStatistic *
  10. ASC_OR_DESC String => column sort sequence, "A" => ascending, * "D" => descending, may be null if sort sequence is not supported; * null when TYPE is tableIndexStatistic *
  11. CARDINALITY int => 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. *
  12. PAGES int => 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. *
  13. FILTER_CONDITION String => Filter condition, if any. * (may be null) *
* * @param catalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param schema a schema name pattern; "" retrieves those without a schema * @param table a table name * @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 * @return ResultSet - each row is an index column description * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException { return null; } //--------------------------JDBC 2.0----------------------------- /** * Does the database support the given result set type? * * @param type defined in java.sql.ResultSet * @return true if so * @throws SQLException if a database-access error occurs. * @see Connection */ public boolean supportsResultSetType(int type) throws SQLException { throw new SQLException("not implemented"); } /** * Does the database support the concurrency type in combination * with the given result set type? * * @param type defined in java.sql.ResultSet * @param concurrency type defined in java.sql.ResultSet * @return true if so * @throws SQLException if a database-access error occurs. * @see Connection */ public boolean supportsResultSetConcurrency(int type, int concurrency) throws SQLException { throw new SQLException("not implemented"); } /** * Determine whether a result set's own changes visible. * * @param result set type, i.e. ResultSet.TYPE_XXX * @return true if changes are visible for the result set type * @throws SQLException if a database-access error occurs. */ public boolean ownUpdatesAreVisible(int type) throws SQLException { throw new SQLException("not implemented"); } public boolean ownDeletesAreVisible(int type) throws SQLException { throw new SQLException("not implemented"); } public boolean ownInsertsAreVisible(int type) throws SQLException { throw new SQLException("not implemented"); } /** * Determine whether changes made by others are visible. * * @param result set type, i.e. ResultSet.TYPE_XXX * @return true if changes are visible for the result set type * @throws SQLException if a database-access error occurs. */ public boolean othersUpdatesAreVisible(int type) throws SQLException { throw new SQLException("not implemented"); } public boolean othersDeletesAreVisible(int type) throws SQLException { throw new SQLException("not implemented"); } public boolean othersInsertsAreVisible(int type) throws SQLException { throw new SQLException("not implemented"); } /** * Determine whether or not a visible row update can be detected by * calling ResultSet.rowUpdated(). * * @param result set type, i.e. ResultSet.TYPE_XXX * @return true if changes are detected by the resultset type * @throws SQLException if a database-access error occurs. */ public boolean updatesAreDetected(int type) throws SQLException { throw new SQLException("not implemented"); } /** * Determine whether or not a visible row delete can be detected by * calling ResultSet.rowDeleted(). If deletesAreDetected() * returns false, then deleted rows are removed from the result set. * * @param result set type, i.e. ResultSet.TYPE_XXX * @return true if changes are detected by the resultset type * @throws SQLException if a database-access error occurs. */ public boolean deletesAreDetected(int type) throws SQLException { throw new SQLException("not implemented"); } /** * Determine whether or not a visible row insert can be detected * by calling ResultSet.rowInserted(). * * @param result set type, i.e. ResultSet.TYPE_XXX * @return true if changes are detected by the resultset type * @throws SQLException if a database-access error occurs. */ public boolean insertsAreDetected(int type) throws SQLException { throw new SQLException("not implemented"); } /** * Return true if the driver supports batch updates, else return false. */ public boolean supportsBatchUpdates() throws SQLException { throw new SQLException("not implemented"); } /** * Get a description of the user-defined types defined in a particular * schema. Schema specific UDTs may have type JAVA_OBJECT, STRUCT, * or DISTINCT. * *

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. * *

Each type description has the following columns: *

    *
  1. TYPE_CAT String => the type's catalog (may be null) *
  2. TYPE_SCHEM String => type's schema (may be null) *
  3. TYPE_NAME String => type name *
  4. CLASS_NAME String => Java class name *
  5. DATA_TYPE String => type value defined in java.sql.Types. * One of JAVA_OBJECT, STRUCT, or DISTINCT *
  6. REMARKS String => explanatory comment on the type *
* *

Note: If the driver does not support UDTs then an empty * result set is returned. * * @param catalog a catalog name; "" retrieves those without a * catalog; null 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 (JAVA_OBJECT, * STRUCT, or DISTINCT); null returns all types * @return ResultSet - each row is a type description * @throws SQLException if a database-access error occurs. */ public java.sql.ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException { throw new SQLException("not implemented"); } /** * Return the connection that produced this metadata object. */ public java.sql.Connection getConnection() throws SQLException { throw new SQLException("not implemented"); } }