/* * 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. */ package java.sql; /** * An interface which provides comprehensive information about the database * management system and its supported features. *

* This interface is implemented by JDBC driver vendors in order to provide * information about the underlying database capabilities in association with * the JDBC driver. *

* Some of the methods in this interface take string parameters which are * patterns. Within these string patterns, {@code '%'} and {@code '_'} * characters have special meanings. {@code '%'} means * "match any substring of 0 or more characters". {@code '_'} means * "match any character". Only metadata entries that match the pattern are * returned. If such a search pattern string is set to {@code null}, that * argument's criteria are dropped from the search. */ public interface DatabaseMetaData extends Wrapper { /** * States that it may not be permitted to store {@code NULL} values. */ public static final short attributeNoNulls = 0; /** * States that {@code NULL} values are definitely permitted. */ public static final short attributeNullable = 1; /** * States that whether {@code NULL} values are permitted is unknown. */ public static final short attributeNullableUnknown = 2; /** * States the best row identifier is NOT a pseudo column. */ public static final int bestRowNotPseudo = 1; /** * States that the best row identifier is a pseudo column. */ public static final int bestRowPseudo = 2; /** * States that the remainder of the current session is used as the scope for * the best row identifier. */ public static final int bestRowSession = 2; /** * States that best row identifier scope lasts only while the row is being * used. */ public static final int bestRowTemporary = 0; /** * States that the remainder of the current transaction is used as the scope * for the best row identifier. */ public static final int bestRowTransaction = 1; /** * States that the best row identifier may or may not be a pseudo column. */ public static final int bestRowUnknown = 0; /** * States that the column must not allow {@code NULL} values. */ public static final int columnNoNulls = 0; /** * States that the column definitely allows {@code NULL} values. */ public static final int columnNullable = 1; /** * States that it is unknown whether the columns may be nulled. */ public static final int columnNullableUnknown = 2; /** * For the column {@code UPDATE_RULE}, states that when the primary key is * updated, the foreign key (imported key) is changed accordingly. */ public static final int importedKeyCascade = 0; /** * States that the evaluation of foreign key constraints is deferred (delayed * until commit). */ public static final int importedKeyInitiallyDeferred = 5; /** * States that the evaluation of foreign key constraint is {@code IMMEDIATE} * . */ public static final int importedKeyInitiallyImmediate = 6; /** * For the columns {@code UPDATE_RULE} and {@code DELETE_RULE}, states that * if the primary key has been imported, it cannot be updated or deleted. */ public static final int importedKeyNoAction = 3; /** * States that the evaluation of foreign key constraint must not be {@code * DEFERRED}. */ public static final int importedKeyNotDeferrable = 7; /** * States that a primary key must not be updated when imported as a foreign * key by some other table. Used for the column {@code UPDATE_RULE}. */ public static final int importedKeyRestrict = 1; /** * States that when the primary key is modified (updated or deleted) the * foreign (imported) key is changed to its default value. Applies to the * {@code UPDATE_RULE} and {@code DELETE_RULE} columns. */ public static final int importedKeySetDefault = 4; /** * States that when the primary key is modified (updated or deleted) the * foreign (imported) key is changed to {@code NULL}. Applies to the {@code * UPDATE_RULE} and {@code DELETE_RULE} columns. */ public static final int importedKeySetNull = 2; /** * States that the column stores {@code IN} type parameters. */ public static final int procedureColumnIn = 1; /** * States that this column stores {@code INOUT} type parameters. */ public static final int procedureColumnInOut = 2; /** * States that this column stores {@code OUT} type parameters. */ public static final int procedureColumnOut = 4; /** * States that the column stores results. */ public static final int procedureColumnResult = 3; /** * States that the column stores return values. */ public static final int procedureColumnReturn = 5; /** * States that type of the column is unknown. */ public static final int procedureColumnUnknown = 0; /** * States that {@code NULL} values are not permitted. */ public static final int procedureNoNulls = 0; /** * States that the procedure does not return a result. */ public static final int procedureNoResult = 1; /** * States that {@code NULL} values are permitted. */ public static final int procedureNullable = 1; /** * States that it is unknown whether {@code NULL} values are permitted. */ public static final int procedureNullableUnknown = 2; /** * States that it is unknown whether or not the procedure returns a result. */ public static final int procedureResultUnknown = 0; /** * States that the procedure returns a result. */ public static final int procedureReturnsResult = 2; /** * States that the value is an SQL99 {@code SQLSTATE} value. */ public static final int sqlStateSQL99 = 2; /** * States that the value is an SQL {@code CLI SQLSTATE} value as defined by * the X/Open standard. */ public static final int sqlStateXOpen = 1; /** * States that this table index is a clustered index. */ public static final short tableIndexClustered = 1; /** * States that this table index is a hashed index. */ public static final short tableIndexHashed = 2; /** * States this table's index is neither a clustered index, not a hashed * index, and not a table statistics index; i.e. it is something else. */ public static final short tableIndexOther = 3; /** * States this column has the table's statistics, and that it is returned in * conjunction with the table's index description. */ public static final short tableIndexStatistic = 0; /** * States that a {@code NULL} value is NOT permitted for * this data type. */ public static final int typeNoNulls = 0; /** * States that a {@code NULL} value is permitted for this data type. */ public static final int typeNullable = 1; /** * States that it is unknown if a {@code NULL} value is permitted for * this data type. */ public static final int typeNullableUnknown = 2; /** * States that this column shall not be used for {@code WHERE} statements * with a {@code LIKE} clause. */ public static final int typePredBasic = 2; /** * States that this column can only be used in a {@code WHERE...LIKE} * statement. */ public static final int typePredChar = 1; /** * States that this column does not support searches. */ public static final int typePredNone = 0; /** * States that the column is searchable. */ public static final int typeSearchable = 3; /** * States that the version column is known to be not a pseudo column. */ public static final int versionColumnNotPseudo = 1; /** * States that this version column is known to be a pseudo column. */ public static final int versionColumnPseudo = 2; /** * States that the version column may be a pseudo column or not. */ public static final int versionColumnUnknown = 0; /** * States that the method DatabaseMetaData.getSQLStateType may returns an * SQLSTATE value or not. */ public static final int sqlStateSQL = 2; /** * States that the parameter or column is an IN parameter */ public static final int functionColumnIn = 1; /** * States that the parameter or column is an INOUT parameter */ public static final int functionColumnInOut = 2; /** * States that the parameter or column is an OUT parameter */ public static final int functionColumnOut = 3; /** * States that the parameter or column is a return value */ public static final int functionReturn = 4; /** * States that the parameter of function is unknown */ public static final int functionColumnUnknown = 0; /** * States that the parameter or column is a column in a result set */ public static final int functionColumnResult = 5; /** * States that NULL values are not allowed */ public static final int functionNoNulls = 0; /** * States that NULL values are allowed */ public static final int functionNullable = 1; /** * States that whether NULL values are allowed is unknown */ public static final int functionNullableUnknown = 2; /** * States that it is not known whether the function returns a result or a * table */ public static final int functionResultUnknown = 0; /** * States that the function does not return a table */ public static final int functionNoTable = 1; /** * States that the function returns a table. */ public static final int functionReturnsTable = 2; /** * Returns whether all procedures returned by {@link #getProcedures} can be * called by the current user. * * @return {@code true} if all procedures can be called by the current user, * {@code false} otherwise. * @throws SQLException * if there is a database error. */ public boolean allProceduresAreCallable() throws SQLException; /** * Returns whether all the tables returned by {@code getTables} can be used * by the current user in a {@code SELECT} statement. * * @return {@code true} if all the tables can be used,{@code false} * otherwise. * @throws SQLException * if there is a database error. */ public boolean allTablesAreSelectable() throws SQLException; /** * Returns whether a data definition statement in a transaction forces a {@code * commit} of the transaction. * * @return {@code true} if the statement forces a commit, {@code false} * otherwise. * @throws SQLException * if there is a database error. */ public boolean dataDefinitionCausesTransactionCommit() throws SQLException; /** * Returns whether the database ignores data definition statements within a * transaction. * * @return {@code true} if the database ignores a data definition statement, * {@code false} otherwise. * @throws SQLException * if there is a database error. */ public boolean dataDefinitionIgnoredInTransactions() throws SQLException; /** * Returns whether a visible row delete can be detected by calling * {@link ResultSet#rowDeleted}. * * @param type * the type of the {@code ResultSet} involved: {@code * ResultSet.TYPE_FORWARD_ONLY}, {@code * ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} if the visible row delete can be detected, {@code * false} otherwise. * @throws SQLException * if there is a database error. */ public boolean deletesAreDetected(int type) throws SQLException; /** * Returns whether the return value of {@code getMaxRowSize} includes the * SQL data types {@code LONGVARCHAR} and {@code LONGVARBINARY}. * * @return {@code true} if the return value includes {@code LONGVARBINARY} * and {@code LONGVARCHAR}, otherwise {@code false}. * @throws SQLException * if there is a database error. */ public boolean doesMaxRowSizeIncludeBlobs() throws SQLException; /** * Returns a {@code ResultSet} describing a subset of the attributes of a * specified SQL User Defined Type (UDT) for a specified schema and catalog. * The subset is determined by restricting to those attributes whose * name matches the {@code attributeNamePattern} and whose type name * matches the {@code typeNamePattern}. Each row of the {@code ResultSet} * describes one attribute, and the rows are ordered by the columns {@code TYPE_SCHEM}, * {@code TYPE_NAME} and {@code ORDINAL_POSITION}. Inherited attributes * are not included. *

* The columns of the returned {@code ResultSet} object have the following * names and meanings: *

    *
  1. {@code TYPE_CAT} - String - the type catalog name (possibly {@code * null})
    2. *
  2. {@code TYPE_SCHEM} - String - the type schema name (possibly {@code * null})
    3. *
  3. {@code TYPE_NAME} - String - the type name
    4. *
  4. {@code ATTR_NAME} - String - the attribute name
    5. *
  5. {@code DATA_TYPE} - int - the attribute type as defined in {@code * java.sql.Types}
    6. *
  6. {@code ATTR_TYPE_NAME} - String - the attribute type name. This * depends on the data source. For a {@code UDT} the name is fully * qualified. For a {@code REF} it is both fully qualified and represents * the target type of the reference.
    7. *
  7. {@code ATTR_SIZE} - int - the column size. When referring to char and * date types this value is the maximum number of characters. When referring * to numeric types is is the precision.
    8. *
  8. {@code DECIMAL_DIGITS} - int - how many fractional digits are * supported
    9. *
  9. {@code NUM_PREC_RADIX} - int - numeric values radix
    10. *
  10. {@code NULLABLE} - int - whether {@code NULL} is permitted: * *
    11. *
  11. {@code REMARKS} - String - a comment describing the attribute * (possibly {@code null})
    12. *
  12. ATTR_DEF - String - Default value for the attribute (possibly {@code * null})
    13. *
  13. {@code SQL_DATA_TYPE} - int - not used
    14. *
  14. SQL_DATETIME_SUB - int - not used
    15. *
  15. CHAR_OCTET_LENGTH - int - for {@code CHAR} types, the max number of * bytes in the column
    16. *
  16. ORDINAL_POSITION - int - The index of the column in the table (where * the count starts from 1, not 0)
    17. *
  17. IS_NULLABLE - String - {@code "NO"} = the column does not allow {@code * NULL}s, {@code "YES"} = the column allows {@code NULL}s, "" = status unknown
    18. *
  18. {@code SCOPE_CATALOG} - String - if the {@code DATA_TYPE} is {@code REF}, * this gives the catalog of the table corresponding to the attribute's scope. * NULL if the {@code DATA_TYPE} is not REF.
    19. *
  19. {@code SCOPE_SCHEMA} - String - if the {@code DATA_TYPE} is {@code REF}, * this gives the schema of the table corresponding to the attribute's scope. * NULL if the {@code DATA_TYPE} is not REF.
    20. *
  20. {@code SCOPE_TABLE} - String - if the {@code DATA_TYPE} is {@code REF}, * this gives the name of the table corresponding to the attribute's scope. * NULL if the {@code DATA_TYPE} is not REF.
    21. *
  21. {@code SOURCE_DATA_TYPE} - String - The source type for a user * generated REF type or for a Distinct type. ({@code NULL} if {@code * DATA_TYPE} is not DISTINCT or a user generated REF)
    22. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search by a schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param typeNamePattern * a type name. This pattern must match the type name stored in * the database. * @param attributeNamePattern * an Attribute name. This pattern must match the attribute name as stored in * the database. * @return a {@code ResultSet}, where each row is an attribute description. * @throws SQLException * if there is a database error. */ public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern) throws SQLException; /** * Returns a list of a table's optimal set of columns that uniquely * identify the rows. The results are ordered by {@code SCOPE} (see below). *

* The results are returned as a table, with one entry for each column, as * follows: *

    *
  1. {@code SCOPE} - short - the {@code SCOPE} of the result, as follows: * *
    2. *
  2. {@code COLUMN_NAME} - String - the column name
    3. *
  3. {@code DATA_TYPE} - int - the Type of the data, as defined in {@code * java.sql.Types}
    4. *
  4. {@code TYPE_NAME} - String - the Name of the type - database dependent. * For UDT types the name is fully qualified
    5. *
  5. {@code COLUMN_SIZE} - int - the precision of the data in the column
    6. *
  6. {@code BUFFER_LENGTH} - int - not used
    7. *
  7. {@code DECIMAL_DIGITS} - short - number of fractional digits
    8. *
  8. {@code PSEUDO_COLUMN} - short - whether this is a pseudo column (e.g. * an Oracle {@code ROWID}): * *
    9. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schema * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param table * the table name. This must match the name of the table as * declared in the database. * @param scope * the {@code SCOPE} of interest, values as defined above. * @param nullable * {@code true} = include columns that are nullable, {@code * false} = do not include nullable columns. * @return a {@code ResultSet} where each row is a description of a column * and the complete set of rows is the optimal set for this table. * @throws SQLException * if there is a database error. */ public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException; /** * Returns the set of catalog names available in this database. The set is * returned ordered by catalog name. * * @return a {@code ResultSet} containing the catalog names, with each row * containing one catalog name (as a {@code String}) in the * single column named {@code TABLE_CAT}. * @throws SQLException * if there is a database error. */ public ResultSet getCatalogs() throws SQLException; /** * Returns the separator that this database uses between a catalog name and * table name. * * @return a String containing the separator. * @throws SQLException * if there is a database error. */ public String getCatalogSeparator() throws SQLException; /** * Returns the term that the database vendor prefers term for "catalog". * * @return a String with the vendor's term for "catalog". * @throws SQLException * if there is a database error. */ public String getCatalogTerm() throws SQLException; /** * Returns a description of access rights for a table's columns. Only access * rights matching the criteria for the column name are returned. *

* The description is returned as a {@code ResultSet} with rows of data for * each access right, with columns as follows: *

    *
  1. {@code TABLE_CAT} - String - the catalog name (possibly {@code null})
    2. *
  2. {@code TABLE_SCHEM} - String - the schema name (possibly {@code null})
    3. *
  3. {@code TABLE_NAME} - String - the table name
    4. *
  4. {@code COLUMN_NAME} - String - the Column name
    5. *
  5. {@code GRANTOR} - String - the grantor of access (possibly {@code * null})
    6. *
  6. {@code PRIVILEGE} - String - Access right - one of SELECT, INSERT, * UPDATE, REFERENCES,...
    7. *
  7. {@code IS_GRANTABLE} - String - {@code "YES"} implies that the * receiver can grant access to others, {@code "NO"} if the receiver cannot * grant access to others, {@code null} if unknown.
    8. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schema * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param table * the table name. This must match the name of the table as * declared in the database. * @param columnNamePattern * the column name. This must match the name of a column in the * table in the database. * @return a {@code ResultSet} containing the access rights, one row for * each privilege description. * @throws SQLException * if there is a database error. */ public ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern) throws SQLException; /** * Returns a description of table columns available in a specified catalog. * Only descriptions meeting the specified catalog, schema, table, and column * names are returned. *

* The descriptions are returned as a {@code ResultSet} conforming to the * following data layout, with one row per table column: *

    *
  1. {@code TABLE_CAT} - String - the catalog name (possibly {@code null})
    2. *
  2. {@code TABLE_SCHEM} - String - the schema name (possibly {@code null})
    3. *
  3. {@code TABLE_NAME} - String - the table name
    4. *
  4. {@code COLUMN_NAME} - String - the column name
    5. *
  5. {@code DATA_TYPE} - int - the SQL type as specified in {@code * java.sql.Types}
    6. *
  6. {@code TYPE_NAME} - String - the name of the data type, (database-dependent, * UDT names are fully qualified)
    7. *
  7. {@code COLUMN_SIZE} - int - the column size (the precision for numeric * types, max characters for {@code char} and {@code date} types)
    8. *
  8. {@code BUFFER_LENGTH} - int - Not used
    9. *
  9. {@code DECIMAL_DIGITS} - int - maximum number of fractional digits
    10. *
  10. {@code NUM_PREC_RADIX} - int - the radix for numerical types
    11. *
  11. {@code NULLABLE} - int - whether the column allows {@code null}s: * *
    12. *
  12. {@code REMARKS} - String - A description of the column (possibly * {@code null})
    13. *
  13. {@code COLUMN_DEF} - String - Default value for the column (possibly * {@code null})
    14. *
  14. {@code SQL_DATA_TYPE} - int - not used
    15. *
  15. {@code SQL_DATETIME_SUB} - int - not used
    16. *
  16. {@code CHAR_OCTET_LENGTH} - int - maximum number of bytes in the * {@code char} type columns
    17. *
  17. {@code ORDINAL_POSITION} - int - the column index in the table (1 based)
    18. *
  18. {@code IS_NULLABLE} - String - {@code "NO"} = column does not allow * NULLs, {@code "YES"} = column allows NULLs, "" = {@code NULL} status * unknown
    19. *
  19. {@code SCOPE_CATALOG} - String - if the {@code DATA_TYPE} is {@code REF}, * this gives the catalog of the table corresponding to the attribute's scope. * NULL if the {@code DATA_TYPE} is not REF.
    20. *
  20. {@code SCOPE_SCHEMA} - String - if the {@code DATA_TYPE} is {@code REF}, * this gives the schema of the table corresponding to the attribute's scope. * NULL if the {@code DATA_TYPE} is not REF.
    21. *
  21. {@code SCOPE_TABLE} - String - if the {@code DATA_TYPE} is {@code REF}, * this gives the name of the table corresponding to the attribute's scope. * NULL if the {@code DATA_TYPE} is not REF.
    22. *
  22. {@code SOURCE_DATA_TYPE} - String - The source type for a user * generated REF type or for a Distinct type. ({@code NULL} if {@code * DATA_TYPE} is not DISTINCT or a user generated REF)
    23. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param tableNamePattern * the table name. This must match the name of the table as * declared in the database. * @param columnNamePattern * the column name. This must match the name of a column in the * table in the database. * @return the descriptions as a {@code ResultSet} with rows in the form * defined above. * @throws SQLException * if there is a database error. */ public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException; /** * Returns the database connection that created this metadata. * * @return the connection to the database. * @throws SQLException * if there is a database error. */ public Connection getConnection() throws SQLException; /** * Returns a list of foreign key columns in a given foreign key table that * reference the primary key columns of a supplied primary key table. This * describes how one table imports the key of another table. It would be * expected to return a single foreign key - primary key pair in most cases. *

* The descriptions are returned as a {@code ResultSet} with one row for * each foreign key, with the following layout: *

    *
  1. {@code PKTABLE_CAT} - String - from the primary key table : Catalog * (possibly {@code null})
    2. *
  2. {@code PKTABLE_SCHEM} - String - from the primary key table : Schema * (possibly {@code null})
    3. *
  3. {@code PKTABLE_NAME} - String - from the primary key table : name
    4. *
  4. {@code PKCOLUMN_NAME} - String - from the primary key column : name
    5. *
  5. {@code FKTABLE_CAT} - String - from the foreign key table : the * catalog name being exported (possibly {@code null})
    6. *
  6. {@code FKTABLE_SCHEM} - String - from the foreign key table : the schema name * being exported (possibly {@code null})
    7. *
  7. {@code FKTABLE_NAME} - String - from the foreign key table : the name being * exported
    8. *
  8. {@code FKCOLUMN_NAME} - String - from the foreign key column : the name being * exported
    9. *
  9. {@code KEY_SEQ} - short - the sequence number (in the foreign key)
    10. *
  10. {@code UPDATE_RULE} - short - a value giving the rule for how to treat the corresponding foreign key when a primary * key is updated: * *
    11. *
  11. {@code DELETE_RULE} - short - a value giving the rule for how to treat the foreign key when the corresponding primary * key is deleted: * *
    12. *
  12. {@code FK_NAME} - String - the foreign key name (possibly {@code null})
    13. *
  13. {@code PK_NAME} - String - the primary key name (possibly {@code null})
    14. *
  14. {@code DEFERRABILITY} - short - whether foreign key constraints can be * deferred until commit (see the SQL92 specification for definitions): * *
    15. *
* * @param primaryCatalog * a catalog name for the primary key table. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param primarySchema * a schema name for the primary key table. {@code null} is used to imply no narrowing of * the search by schema name. Otherwise, the name must match a * schema name in the database, with "" used to retrieve those * without a schema name. * @param primaryTable * the name of the table which exports the key. It must match the * name of the table in the database. * @param foreignCatalog * a catalog name for the foreign key table. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param foreignSchema * a schema name for the foreign key table. {@code null} is used to imply no narrowing of * the search by schema name. Otherwise, the name must match a * schema name in the database, with "" used to retrieve those * without a schema name. * @param foreignTable * the name of the table importing the key. It must match the * name of the table in the database. * @return a {@code ResultSet} containing rows with the descriptions of the * foreign keys laid out according to the format defined above. * @throws SQLException * if there is a database error. */ public ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException; /** * Returns the major version number of the database software. * * @return the major version number of the database software. * @throws SQLException * a database error occurred. */ public int getDatabaseMajorVersion() throws SQLException; /** * Returns the minor version number of the database software. * * @return the minor version number of the database software. * @throws SQLException * a database error occurred. */ public int getDatabaseMinorVersion() throws SQLException; /** * Returns the name of the database software. * * @return a {@code String} with the name of the database software. * @throws SQLException * a database error occurred. */ public String getDatabaseProductName() throws SQLException; /** * Returns the version number of this database software. * * @return a {@code String} with the version number of the database * software. * @throws SQLException * a database error occurred. */ public String getDatabaseProductVersion() throws SQLException; /** * Returns the default transaction isolation level for this database. * * @return the default transaction isolation level. One of the following values: * * @throws SQLException * a database error occurred. */ public int getDefaultTransactionIsolation() throws SQLException; /** * Returns the JDBC driver's major version number. * * @return the driver's major version number. */ public int getDriverMajorVersion(); /** * Returns the JDBC driver's minor version number. * * @return the driver's minor version number. */ public int getDriverMinorVersion(); /** * Returns the name of this JDBC driver. * * @return a {@code String} containing the name of the JDBC driver * @throws SQLException * a database error occurred. */ public String getDriverName() throws SQLException; /** * Returns the version number of this JDBC driver. * * @return a {@code String} containing the complete version number of the * JDBC driver. * @throws SQLException * a database error occurred. */ public String getDriverVersion() throws SQLException; /** * Returns a list of the foreign key columns that reference the primary key * columns of a specified table (the foreign keys exported by a table). *

* The list is returned as a {@code ResultSet} with a row for each of the * foreign key columns, ordered by {@code FKTABLE_CAT}, {@code * FKTABLE_SCHEM}, {@code FKTABLE_NAME}, and {@code KEY_SEQ}, with the * format for each row being: *

    *
  1. {@code PKTABLE_CAT} - String - from the primary key table : the catalog (possibly * {@code null})
    2. *
  2. {@code PKTABLE_SCHEM} - String - from the primary key table : the schema (possibly * {@code null})
    3. *
  3. {@code PKTABLE_NAME} - String - from the primary key table : the name
    4. *
  4. {@code PKCOLUMN_NAME} - String - from the primary key column : the name
    5. *
  5. {@code FKTABLE_CAT} - String - from the foreign key table : the catalog name being * exported (possibly {@code null})
    6. *
  6. {@code FKTABLE_SCHEM} - String - from the foreign key table : the schema name * being exported (possibly {@code null})
    7. *
  7. {@code FKTABLE_NAME} - String - from the foreign key table : the name being * exported
    8. *
  8. {@code FKCOLUMN_NAME} - String - from the foreign key column : the name being * exported
    9. *
  9. {@code KEY_SEQ} - short - the sequence number (in the foreign key)
    10. *
  10. {@code UPDATE_RULE} - short - a value giving the rule for how to treat the foreign key when the corresponding primary * key is updated: * *
    11. *
  11. {@code DELETE_RULE} - short - how to treat the foreign key when the corresponding primary * key is deleted: * *
    12. *
  12. {@code FK_NAME} - String - the foreign key name (possibly {@code null})
    13. *
  13. {@code PK_NAME} - String - the primary key name (possibly {@code null})
    14. *
  14. {@code DEFERRABILITY} - short - defines whether the foreign key * constraints can be deferred until commit (see the SQL92 specification for * definitions): * *
    15. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schema * a schema name. {@code null} is used to imply no narrowing of * the search by schema name. Otherwise, the name must match a * schema name in the database, with "" used to retrieve those * without a schema name. * @param table * a table name, which must match the name of a table in the * database * @return a {@code ResultSet} containing a row for each of the foreign key * columns, as defined above * @throws SQLException * a database error occurred */ public ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException; /** * Returns a string of characters that may be used in unquoted identifier * names. The characters {@code a-z}, {@code A-Z}, {@code 0-9} and {@code _} * are always permitted. * * @return a String containing all the additional permitted characters. * @throws SQLException * a database error occurred. */ public String getExtraNameCharacters() throws SQLException; /** * Returns the string used to quote SQL identifiers. Returns " " (space) if * identifier quoting not supported. * * @return the String used to quote SQL identifiers. * @throws SQLException * a database error occurred. */ public String getIdentifierQuoteString() throws SQLException; /** * Returns a list columns in a table that are both primary keys and * referenced by the table's foreign key columns (that is, the primary keys * imported by a table). *

* The list returned is a {@code ResultSet} with a row entry for each * primary key column, ordered by {@code PKTABLE_CAT}, {@code PKTABLE_SCHEM}, * {@code PKTABLE_NAME}, and {@code KEY_SEQ}, with the following format: *

    *
  1. {@code PKTABLE_CAT} - String - primary key catalog name being * imported (possibly {@code null})
    2. *
  2. {@code PKTABLE_SCHEM} - String - primary key schema name being * imported (possibly {@code null})
    3. *
  3. {@code PKTABLE_NAME} - String - primary key table name being imported *
    4. *
  4. {@code PKCOLUMN_NAME} - String - primary key column name being * imported
    5. *
  5. {@code FKTABLE_CAT} - String - foreign key table catalog name * (possibly {@code null})
    6. *
  6. {@code FKTABLE_SCHEM} - String - foreign key table schema name * (possibly {@code null})
    7. *
  7. {@code FKTABLE_NAME} - String - foreign key table name
    8. *
  8. {@code FKCOLUMN_NAME} - String - foreign key column name
    9. *
  9. {@code KEY_SEQ} - short - sequence number (in the foreign key)
    10. *
  10. {@code UPDATE_RULE} - short - how to treat the foreign key when the corresponding primary * key is updated: * *
    11. *
  11. {@code DELETE_RULE} - short - how to treat the foreign key when the corresponding primary * key is deleted: * *
    12. *
  12. {@code FK_NAME} - String - foreign key name (possibly {@code null})
    13. *
  13. {@code PK_NAME} - String - primary key name (possibly {@code null})
    14. *
  14. {@code DEFERRABILITY} - short - defines whether foreign key * constraints can be deferred until commit (see SQL92 specification for * definitions): * *
    15. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schema * a schema name. {@code null} is used to imply no narrowing of * the search by schema name. Otherwise, the name must match a * schema name in the database, with "" used to retrieve those * without a schema name. * @param table * a table name, which must match the name of a table in the * database. * @return a {@code ResultSet} containing the list of primary key columns as * rows in the format defined above. * @throws SQLException * a database error occurred. */ public ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException; /** * Returns a list of indices and statistics for a specified table. *

* The list is returned as a {@code ResultSet}, with one row for each index * or statistic. The list is ordered by {@code NON_UNIQUE}, {@code TYPE}, * {@code INDEX_NAME}, and {@code ORDINAL_POSITION}. Each row has the * following format: *

    *
  1. {@code TABLE_CAT} - String - table catalog name (possibly {@code * null})
    2. *
  2. {@code TABLE_SCHEM} - String - table schema name (possibly {@code * null})
    3. *
  3. {@code TABLE_NAME} - String - The table name
    4. *
  4. {@code NON_UNIQUE} - boolean - {@code true} when index values can be * non-unique. Must be {@code false} when the TYPE is tableIndexStatistic
    5. *
  5. {@code INDEX_QUALIFIER} - String : index catalog name. {@code null} * when the TYPE is 'tableIndexStatistic'
    6. *
  6. {@code INDEX_NAME} - String : index name. {@code null} when TYPE is * 'tableIndexStatistic'
    7. *
  7. {@code TYPE} - short - the index type. One of: * *
    8. *
  8. {@code ORDINAL_POSITION} - short - column sequence within Index. 0 * when TYPE is tableIndexStatistic
    9. *
  9. {@code COLUMN_NAME} - String - the column name. {@code null} when * TYPE is tableIndexStatistic
    10. *
  10. {@code ASC_OR_DESC} - String - column sort sequence. {@code null} if * sequencing not supported or TYPE is tableIndexStatistic; otherwise "A" * means sort ascending and "D" means sort descending.
    11. *
  11. {@code CARDINALITY} - int - Number of unique values in the Index. If * TYPE is tableIndexStatistic, this is number of rows in the table.
    12. *
  12. {@code PAGES} - int - Number of pages for current Index. If TYPE is * tableIndexStatistic, this is number of pages used for the table.
    13. *
  13. {@code FILTER_CONDITION} - String - Filter condition. (possibly null) *
    14. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schema * a schema name. {@code null} is used to imply no narrowing of * the search by schema name. Otherwise, the name must match a * schema name in the database, with "" used to retrieve those * without a schema name. * @param table * a table name, which must match the name of a table in the * database. * @param unique * {@code true} means only return indices for unique values, * {@code false} implies that they can be returned even if not * unique. * @param approximate * {@code true} implies that the list can contain approximate or * "out of data" values, {@code false} implies that all values * must be precisely accurate * @return a {@code ResultSet} containing the list of indices and statistics * for the table, in the format defined above. * @throws SQLException * a database error occurred. */ public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException; /** * Returns this driver's major JDBC version number. * * @return the major JDBC version number. * @throws SQLException * a database error occurred. */ public int getJDBCMajorVersion() throws SQLException; /** * Returns the minor JDBC version number for this driver. * * @return the Minor JDBC Version Number. * @throws SQLException * a database error occurred. */ public int getJDBCMinorVersion() throws SQLException; /** * Get the maximum number of hex characters in an in-line binary literal for * this database. * * @return the maximum number of hex characters in an in-line binary * literal. If the number is unlimited then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxBinaryLiteralLength() throws SQLException; /** * Returns the maximum size of a catalog name in this database. * * @return the maximum size in characters for a catalog name. If the limit * is unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxCatalogNameLength() throws SQLException; /** * Returns the maximum size for a character literal in this database. * * @return the maximum size in characters for a character literal. If the * limit is unknown, or the value is unlimited, then the result is * zero. * @throws SQLException * a database error occurred. */ public int getMaxCharLiteralLength() throws SQLException; /** * Returns the maximum size for a Column name for this database. * * @return the maximum number of characters for a Column name. If the limit * is unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxColumnNameLength() throws SQLException; /** * Get the maximum number of columns in a {@code GROUP BY} clause for this * database. * * @return the maximum number of columns in a {@code GROUP BY} clause. If * the limit is unknown, or the value is unlimited, then the result * is zero. * @throws SQLException * a database error occurred. */ public int getMaxColumnsInGroupBy() throws SQLException; /** * Returns the maximum number of columns in an Index for this database. * * @return the maximum number of columns in an Index. If the limit is * unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxColumnsInIndex() throws SQLException; /** * Returns the maximum number of columns in an {@code ORDER BY} clause for * this database. * * @return the maximum number of columns in an {@code ORDER BY} clause. If * the limit is unknown, or the value is unlimited, then the result * is zero. * @throws SQLException * a database error occurred. */ public int getMaxColumnsInOrderBy() throws SQLException; /** * Returns the maximum number of columns in a {@code SELECT} list for this * database. * * @return the maximum number of columns in a {@code SELECT} list. If the * limit is unknown, or the value is unlimited, then the result is * zero. * @throws SQLException * a database error occurred. */ public int getMaxColumnsInSelect() throws SQLException; /** * Returns the maximum number of columns in a table for this database. * * @return the maximum number of columns in a table. If the limit is * unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxColumnsInTable() throws SQLException; /** * Returns the database's maximum number of concurrent connections. * * @return the maximum number of connections. If the limit is unknown, or * the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxConnections() throws SQLException; /** * Returns the maximum length of a cursor name for this database. * * @return the maximum number of characters in a cursor name. If the limit * is unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxCursorNameLength() throws SQLException; /** * Returns the maximum length in bytes for an Index for this database. This * covers all the parts of a composite index. * * @return the maximum length in bytes for an Index. If the limit is * unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxIndexLength() throws SQLException; /** * Returns the maximum number of characters for a procedure name in this * database. * * @return the maximum number of character for a procedure name. If the * limit is unknown, or the value is unlimited, then the result is * zero. * @throws SQLException * a database error occurred. */ public int getMaxProcedureNameLength() throws SQLException; /** * Returns the maximum number of bytes within a single row for this * database. * * @return the maximum number of bytes for a single row. If the limit is * unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxRowSize() throws SQLException; /** * Returns the maximum number of characters in a schema name for this * database. * * @return the maximum number of characters in a schema name. If the limit * is unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxSchemaNameLength() throws SQLException; /** * Returns the maximum number of characters in an SQL statement for this * database. * * @return the maximum number of characters in an SQL statement. If the * limit is unknown, or the value is unlimited, then the result is * zero. * @throws SQLException * a database error occurred. */ public int getMaxStatementLength() throws SQLException; /** * Get the maximum number of simultaneously open active statements for this * database. * * @return the maximum number of open active statements. If the limit is * unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxStatements() throws SQLException; /** * Returns the maximum size for a table name in the database. * * @return the maximum size in characters for a table name. If the limit is * unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxTableNameLength() throws SQLException; /** * Returns the maximum number of tables permitted in a {@code SELECT} * statement for the database. * * @return the maximum number of tables permitted in a {@code SELECT} * statement. If the limit is unknown, or the value is unlimited, * then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxTablesInSelect() throws SQLException; /** * Returns the maximum number of characters in a user name for the database. * * @return the maximum number of characters in a user name. If the limit is * unknown, or the value is unlimited, then the result is zero. * @throws SQLException * a database error occurred. */ public int getMaxUserNameLength() throws SQLException; /** * Returns a list of the math functions available with this database. These * are used in the JDBC function escape clause and are the Open Group CLI * math function names. * * @return a String which contains the list of math functions as a comma * separated list. * @throws SQLException * a database error occurred. */ public String getNumericFunctions() throws SQLException; /** * Returns a list of the primary key columns of a specified table. *

* The list is returned as a {@code ResultSet} with one row for each primary * key column, ordered by {@code COLUMN_NAME}, with each row having the * structure as follows: *

    *
  1. {@code TABLE_CAT} - String - table catalog name (possibly null)
    2. *
  2. {@code TABLE_SCHEM} - String - table schema name (possibly null)
    3. *
  3. {@code TABLE_NAME} - String - The table name
    4. *
  4. {@code COLUMN_NAME} - String - The column name
    5. *
  5. {@code KEY_SEQ} - short - the sequence number for this column in the * primary key
    6. *
  6. {@code PK_NAME} - String - the primary key name (possibly null)
    7. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with the empty string used * to retrieve those without a catalog name. * @param schema * a schema name. {@code null} is used to imply no narrowing of * the search by schema name. Otherwise, the name must match a * schema name in the database, with the empty string used to * retrieve those without a schema name. * @param table * the name of a table, which must match the name of a table in * the database. * @return a {@code ResultSet} containing the list of keys in the format * defined above. * @throws SQLException * a database error occurred. */ public ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException; /** * Returns a list of parameter and result columns for the stored procedures * belonging to a specified catalog. *

* The list is returned as a {@code ResultSet} with one row for each * parameter or result column. The data is ordered by {@code * PROCEDURE_SCHEM} and {@code PROCEDURE_NAME}, while for each procedure, * the return value (if any) is first, followed by the parameters in the * order they appear in the stored procedure call, followed by {@code * ResultSet} columns in column number order. Each row has the following * structure: *

    *
  1. {@code PROCEDURE_CAT} - String - the procedure catalog name
    2. *
  2. {@code PROCEDURE_SCHEM} - String - the procedure schema name * (possibly null)
    3. *
  3. {@code PROCEDURE_NAME} - String - the procedure name
    4. *
  4. {@code COLUMN_NAME} - String - the name of the column
    5. *
  5. {@code COLUMN_TYPE} - short - the kind of column or parameter, as * follows: * *
    6. *
  6. {@code DATA_TYPE} - int - the SQL type of the data, as in {@code * java.sql.Types}
    7. *
  7. {@code TYPE_NAME} - String - the SQL type name, for a UDT it is fully * qualified
    8. *
  8. {@code PRECISION} - int - the precision
    9. *
  9. {@code LENGTH} - int - the length of the data in bytes
    10. *
  10. {@code SCALE} - short - the scale for numeric types
    11. *
  11. {@code RADIX} - short - the Radix for numeric data (typically 2 or * 10)
    12. *
  12. {@code NULLABLE} - short - can the data contain {@code null}: * *
    13. *
  13. {@code REMARKS} - String - an explanatory comment about the data item *
    14. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param procedureNamePattern * a pattern that must match the name of the procedure stored in * the database. * @param columnNamePattern * a column name pattern. The name must match the column name * stored in the database. * @return a {@code ResultSet} with the list of parameter and result columns * in the format defined above. * @throws SQLException * a database error occurred. */ public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException; /** * Returns a list of the stored procedures available in a specified catalog. *

* The list is returned as a {@code ResultSet} with one row for each stored * procedure, ordered by PROCEDURE_SCHEM and PROCEDURE_NAME, with the data * in each row as follows: *

    *
  1. {@code PROCEDURE_CAT} - String : the procedure catalog name
    2. *
  2. {@code PROCEDURE_SCHEM} - String : the procedure schema name * (possibly {@code null})
    3. *
  3. {@code PROCEDURE_NAME} - String : the procedure name
    4. *
  4. {@code Reserved}
    5. *
  5. {@code Reserved}
    6. *
  6. {@code Reserved}
    7. *
  7. {@code REMARKS} - String - information about the procedure
    8. *
  8. {@code PROCEDURE_TYPE} - short : one of: * *
    9. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param procedureNamePattern * a procedure name pattern, which must match the procedure name * stored in the database. * @return a {@code ResultSet} where each row is a description of a stored * procedure in the format defined above. * @throws SQLException * a database error occurred. */ public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException; /** * Returns the database vendor's preferred name for "procedure". * * @return a String with the vendor's preferred name for "procedure". * @throws SQLException * a database error occurred. */ public String getProcedureTerm() throws SQLException; /** * Returns the result set's default holdability. * * @return one of {@code ResultSet.HOLD_CURSORS_OVER_COMMIT} or {@code * ResultSet.CLOSE_CURSORS_AT_COMMIT}. * @throws SQLException * a database error occurred. */ public int getResultSetHoldability() throws SQLException; /** * Returns a list of the schema names in the database. The list is returned * as a {@code ResultSet}, ordered by the schema name, with one row per * schema in the following format: *
    *
  1. {@code TABLE_SCHEM} - String - the schema name
  2. {@code * TABLE_CATALOG} - String - the catalog name (possibly {@code null})
    3. *
* * @return a {@code ResultSet} with one row for each schema in the format * defined above. * @throws SQLException * a database error occurred. */ public ResultSet getSchemas() throws SQLException; /** * Returns the database vendor's preferred term for "schema". * * @return a String which is the vendor's preferred term for schema. * @throws SQLException * a database error occurred. */ public String getSchemaTerm() throws SQLException; /** * Returns the string that is used to escape wildcard characters. This * string is used to escape the {@code '_'} and {@code '%'} wildcard * characters in catalog search pattern strings. {@code '_'} is used to represent any single * character while {@code '%'} is used for a sequence of zero or more * characters. * * @return a String used to escape the wildcard characters. * @throws SQLException * a database error occurred. */ public String getSearchStringEscape() throws SQLException; /** * Returns a list of all the SQL keywords that are NOT also SQL92 keywords * for the database. * * @return a String containing the list of SQL keywords in a comma separated * format. * @throws SQLException * a database error occurred. */ public String getSQLKeywords() throws SQLException; /** * States the type of {@code SQLState} value returned by {@code * SQLException.getSQLState}. This can either be the X/Open (now known as * Open Group) SQL CLI form or the SQL99 form. * * @return an integer, which is either {@code * DatabaseMetaData.sqlStateSQL99} or {@code * DatabaseMetaData.sqlStateXOpen}. * @throws SQLException * a database error occurred. */ public int getSQLStateType() throws SQLException; /** * Returns a list of string functions available with the database. These * functions are used in JDBC function escape clause and follow the Open * Group CLI string function names definition. * * @return a String containing the list of string functions in comma * separated format. * @throws SQLException * a database error occurred. */ public String getStringFunctions() throws SQLException; /** * Returns a listing of the hierarchies of tables in a specified schema in * the database. *

* The listing only contains entries for tables that have a super table. * Super tables and corresponding subtables must be defined in the same catalog and schema. The * list is returned as a {@code ResultSet}, with one row for each table that * has a super table, in the following format: *

    *
  1. {@code TABLE_CAT} - String - table catalog name (possibly {@code * null})
    2. *
  2. {@code TABLE_SCHEM} - String - Table schema name (possibly {@code * null})
    3. *
  3. {@code TABLE_NAME} - String - The table name
    4. *
  4. SUPER{@code TABLE_NAME} - String - The super table name
    5. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param tableNamePattern * a table name, which should match the table name as stored in * the database. it may be a fully qualified name. If it is fully * qualified the catalog name and schema name parameters are * ignored. * @return a {@code ResultSet} with one row for each table which has a super * table, in the format defined above. An empty {@code ResultSet} is * returned if the database does not support table hierarchies. * @throws SQLException * a database error occurred. */ public ResultSet getSuperTables(String catalog, String schemaPattern, String tableNamePattern) throws SQLException; /** * Returns the User Defined Type (UDT) hierarchies for a given schema. Only * the immediate parent/child relationship is described. If a UDT does not * have a direct supertype, it is not listed. *

* The listing is returned as a {@code ResultSet} where there is one row for * a specific UDT which describes its supertype, with the data organized in * columns as follows: *

    *
  1. {@code TYPE_CAT} - String - the UDT catalog name (possibly {@code * null})
    2. *
  2. {@code TYPE_SCHEM} - String - the UDT schema name (possibly {@code * null})
    3. *
  3. {@code TYPE_NAME} - String - the UDT type name
    4. *
  4. SUPER{@code TYPE_CAT} - String - direct supertype's catalog name * (possibly {@code null})
    5. *
  5. SUPER{@code TYPE_SCHEM} - String - direct supertype's schema name * (possibly {@code null})
    6. *
  6. SUPER{@code TYPE_NAME} - String - direct supertype's name
    7. *
* * @param catalog * the catalog name. "" means get the UDTs without a catalog. * {@code null} means don't use the catalog name to restrict the * search. * @param schemaPattern * the Schema pattern name. "" means get the UDT's without a * schema. * @param typeNamePattern * the UDT name pattern. This may be a fully qualified name. When * a fully qualified name is specified, the catalog name and * schema name parameters are ignored. * @return a {@code ResultSet} in which each row gives information about a * particular UDT in the format defined above. An empty ResultSet is * returned for a database that does not support type hierarchies. * @throws SQLException * a database error occurred. */ public ResultSet getSuperTypes(String catalog, String schemaPattern, String typeNamePattern) throws SQLException; /** * Returns a list of system functions available with the database. These are * names used in the JDBC function escape clause and are Open Group CLI * function names. * * @return a String containing the list of system functions in a comma * separated format. * @throws SQLException * a database error occurred. */ public String getSystemFunctions() throws SQLException; /** * Returns a description of access rights for each table present in a * catalog. Table privileges can apply to one or more columns in the table - * but are not guaranteed to apply to all columns. *

* The privileges are returned as a {@code ResultSet}, with one row for each * privilege, ordered by {@code TABLE_SCHEM}, {@code TABLE_NAME}, {@code * PRIVILEGE}, and each row has data as defined in the following column * definitions: *

    *
  1. {@code TABLE_CAT} - String - table catalog name (possibly {@code * null})
    2. *
  2. {@code TABLE_SCHEM} - String - Table schema name (possibly {@code * null})
    3. *
  3. {@code TABLE_NAME} - String - The table name
    4. *
  4. GRANTOR - String - who granted the access
    5. *
  5. GRANTEE - String - who received the access grant
    6. *
  6. PRIVILEGE - String - the type of access granted - one of SELECT, * INSERT, UPDATE, REFERENCES,...
    7. *
  7. IS_GRANTABLE - String - {@code "YES"} implies the grantee can grant * access to others, {@code "NO"} implies guarantee cannot grant access to * others, {@code null} means this status is unknown
    8. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param tableNamePattern * a Table Name, which should match the table name as stored in * the database. * @return a {@code ResultSet} containing a list with one row for each table * in the format defined above. * @throws SQLException * a database error occurred. */ public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException; /** * Returns a description of the tables in a specified catalog. *

* The descriptions are returned as rows in a {@code ResultSet}, one row for * each Table. The ResultSet is ordered by {@code TABLE_TYPE}, {@code * TABLE_SCHEM} and {@code TABLE_NAME}. Each row in the ResultSet consists * of a series of columns as follows: *

    *
  1. {@code TABLE_CAT} - String - table catalog name (possibly {@code * null})
    2. *
  2. {@code TABLE_SCHEM} - String - Table schema name (possibly {@code * null})
    3. *
  3. {@code TABLE_NAME} - String - The table name
    4. *
  4. {@code TABLE_TYPE} - String - Typical names include "TABLE", "VIEW", * "SYSTEM TABLE", "ALIAS", "SYNONYM", "GLOBAL TEMPORARY"
    5. *
  5. {@code REMARKS} - String - A comment describing the table
    6. *
  6. {@code TYPE_CAT} - String - the 'Types' catalog(possibly {@code null} * )
    7. *
  7. {@code TYPE_SCHEM} - String - the 'Types' schema(possibly {@code * null})
    8. *
  8. {@code TYPE_NAME} - String - the 'Types' name (possibly {@code null}) *
    9. *
  9. {@code SELF_REFERENCING_COL_NAME} - String - the name of a designated * identifier column in a typed table (possibly {@code null})
    10. *
  10. REF_GENERATION - String - one of the following values : "SYSTEM" | * "USER" | "DERIVED" - specifies how values in the {@code * SELF_REFERENCING_COL_NAME} are created (possibly {@code null})
    11. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search by schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param tableNamePattern * a table name, which should match the table name as stored in * the database. * @param types * a list of table types to include in the list. {@code null} * implies list all types. * @return a {@code ResultSet} with one row per table in the format defined * above. * @throws SQLException * a database error occurred. */ public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types) throws SQLException; /** * Returns a list of table types supported by the database. *

* The list is returned as a {@code ResultSet} with one row per table type, * ordered by the table type. The information in the {@code ResultSet} is * structured into a single column per row, as follows: *

    *
  1. {@code TABLE_TYPE} - String - the table type. Typical names include * {@code "TABLE"}, {@code "VIEW"}, "{@code SYSTEM TABLE"}, {@code "ALIAS"}, * {@code "SYNONYM"}, {@code "GLOBAL TEMPORARY"}
    2. *
* * @return a {@code ResultSet} with one row per table type in the format * defined above. * @throws SQLException * a database error occurred. */ public ResultSet getTableTypes() throws SQLException; /** * Returns a list of time and date functions available for the database. * * @return a string containing a comma separated list of the time and date * functions. * @throws SQLException * a database error occurred. */ public String getTimeDateFunctions() throws SQLException; /** * Get a list of the standard SQL types supported by this database. The list * is returned as a {@code ResultSet}, with one row for each type, ordered * by the {@code DATA_TYPE} value, where the data in each row is structured * into the following columns: *
    *
  1. {@code TYPE_NAME} - String : the type name
    2. *
  2. {@code DATA_TYPE} - int : the SQL data type value as defined in * {@code java.sql.Types}
    3. *
  3. {@code PRECISION} - int - the maximum precision of the type
    4. *
  4. {@code LITERAL_PREFIX} - String : the prefix to be used when quoting * a literal value (possibly {@code null})
    5. *
  5. {@code LITERAL_SUFFIX} - String : the suffix to be used when quoting * a literal value (possibly {@code null})
    6. *
  6. {@code CREATE_PARAMS} - String : params used when creating the type * (possibly {@code null})
    7. *
  7. {@code NULLABLE} - short : shows if the value is nullable: * *
    8. *
  8. {@code CASE_SENSITIVE} - boolean : true if the type is case sensitive *
    9. *
  9. {@code SEARCHABLE} - short : how this type can be used with {@code WHERE} * clauses: * *
    10. *
  10. {@code UNSIGNED_ATTRIBUTE} - boolean - the type is unsigned or not
    11. *
  11. {@code FIXED_PREC_SCALE} - boolean - fixed precision = it can be used * as a money value
    12. *
  12. {@code AUTO_INCREMENT} - boolean - can be used as an auto-increment * value
    13. *
  13. {@code LOCAL_TYPE_NAME} - String - a localized version of the type * name (possibly {@code null})
    14. *
  14. {@code MINIMUM_SCALE} - short - the minimum scale supported
    15. *
  15. {@code MAXIMUM_SCALE} - short - the maximum scale supported
    16. *
  16. {@code SQL_DATA_TYPE} - int - not used
    17. *
  17. {@code SQL_DATETIME_SUB} - int - not used
    18. *
  18. {@code NUM_PREC_RADIX} - int - number radix (typically 2 or 10)
    19. *
* * @return a {@code ResultSet} which is structured as described above. * @throws SQLException * a database error occurred. */ public ResultSet getTypeInfo() throws SQLException; /** * Returns a description of the User Defined Types (UDTs) defined in a given * schema, which includes the types {@code DISTINCT}, {@code STRUCT} and * {@code JAVA_OBJECT}. *

* The types matching the supplied the specified catalog, schema, type name * and type are returned as rows in a {@code ResultSet} with columns of * information as follows: *

    *
  1. {@code TABLE_CAT} - String - catalog name (possibly {@code null})
    2. *
  2. {@code TABLE_SCHEM} - String - schema name (possibly {@code null})
    3. *
  3. {@code TABLE_NAME} - String - The table name
    4. *
  4. {@code CLASS_NAME} - String - The Java class name
    5. *
  5. {@code DATA_TYPE} - int - The SQL type as specified in {@code * java.sql.Types}. One of DISTINCT, STRUCT, and JAVA_OBJECT
    6. *
  6. {@code REMARKS} - String - A comment which describes the type
    7. *
  7. {@code BASE_TYPE} - short - A type code. For a DISTINCT type, the * source type. For a structured type this is the type that implements the * user generated reference type of the {@code SELF_REFERENCING_COLUMN}. * This is defined in {@code java.sql.Types}, and will be {@code null} if * the {@code DATA_TYPE} does not match these criteria.
    8. *
*

* If the driver does not support UDTs, the {@code ResultSet} is empty. * * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search by catalog name. Otherwise, the name must match a * catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schemaPattern * a schema name pattern. {@code null} is used to imply no * narrowing of the search using schema name. Otherwise, the name * must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param typeNamePattern * a type name pattern, which should match a type name as stored in the * database. It may be fully qualified. * @param types * a list of the UDT types to include in the list - one of * {@code DISTINCT}, {@code STRUCT} or {@code JAVA_OBJECT}. * @return a {@code ResultSet} in the format described above. * @throws SQLException * a database error occurred. */ public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException; /** * Returns the URL for this database. * * @return the URL for the database. {@code null} if it cannot be generated. * @throws SQLException * a database error occurred. */ public String getURL() throws SQLException; /** * Determine the user name as known by the database. * * @return the user name. * @throws SQLException * a database error occurred. */ public String getUserName() throws SQLException; /** * Returns which of a table's columns are automatically updated when any * value in a row is updated. *

* The result is laid-out in the following columns: *

    *
  1. {@code SCOPE} - short - not used
    2. *
  2. {@code COLUMN_NAME} - String - Column name
    3. *
  3. {@code DATA_TYPE} - int - The SQL data type, as defined in {@code * java.sql.Types}
    4. *
  4. {@code TYPE_NAME} - String - The SQL type name, data source dependent *
    5. *
  5. {@code COLUMN_SIZE} - int - Precision for numeric types
    6. *
  6. {@code BUFFER_LENGTH} - int - Length of a column value in bytes
    7. *
  7. {@code DECIMAL_DIGITS} - short - Number of digits after the decimal * point
    8. *
  8. {@code PSEUDO_COLUMN} - short - If this is a pseudo-column (for * example, an Oracle {@code ROWID}): * *
    9. *
* * @param catalog * a catalog name. {@code null} is used to imply no narrowing of * the search using catalog name. Otherwise, the name must match * a catalog name held in the database, with "" used to retrieve * those without a catalog name. * @param schema * a schema name pattern. {@code null} is used to imply no * narrowing of the search using schema names. Otherwise, the * name must match a schema name in the database, with "" used to * retrieve those without a schema name. * @param table * a table name. It must match the name of a table in the * database. * @return a {@code ResultSet} containing the descriptions, one row for each * column, in the format defined above. * @throws SQLException * a database error occurred. */ public ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException; /** * Determines whether a visible row insert can be detected by calling {@code * ResultSet.rowInserted}. * * @param type * the {@code ResultSet} type. This may be one of {@code * ResultSet.TYPE_SCROLL_SENSITIVE} or {@code * ResultSet.TYPE_SCROLL_INSENSITIVE} or {@code * ResultSet.TYPE_FORWARD_ONLY}, * @return {@code true} if {@code ResultSet.rowInserted} detects a visible * row insert otherwise {@code false}. * @throws SQLException * a database error occurred. * @see ResultSet#rowInserted() */ public boolean insertsAreDetected(int type) throws SQLException; /** * Determine whether a fully qualified table name is prefixed or suffixed to * a fully qualified table name. * * @return {@code true} if the catalog appears at the start of a fully * qualified table name, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean isCatalogAtStart() throws SQLException; /** * Determines whether the database is in read-only mode. * * @return {@code true} if the database is in read-only mode, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean isReadOnly() throws SQLException; /** * Determines whether updates are made to a copy of, or directly on, Large Objects * ({@code LOB}s). * * @return {@code true} if updates are made to a copy of the Large Object, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean locatorsUpdateCopy() throws SQLException; /** * Determines whether the database handles concatenations between {@code NULL} and * non-{@code NULL} values by producing a {@code NULL} output. * * @return {@code true} if {@code NULL} to non-{@code NULL} concatenations * produce a {@code NULL} result, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean nullPlusNonNullIsNull() throws SQLException; /** * Determines whether {@code NULL} values are always sorted to the end of sorted * results regardless of requested sort order. This means that they will * appear at the end of sorted lists whatever other non-{@code NULL} values * may be present. * * @return {@code true} if {@code NULL} values are sorted at the end, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean nullsAreSortedAtEnd() throws SQLException; /** * Determines whether {@code NULL} values are always sorted at the start of the * sorted list, irrespective of the sort order. This means that they appear * at the start of sorted lists, whatever other values may be present. * * @return {@code true} if {@code NULL} values are sorted at the start, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean nullsAreSortedAtStart() throws SQLException; /** * Determines whether {@code NULL} values are sorted high - i.e. they are sorted * as if they are higher than any other values. * * @return {@code true} if {@code NULL} values are sorted high, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean nullsAreSortedHigh() throws SQLException; /** * Determines whether {@code NULL} values are sorted low - i.e. they are sorted as * if they are lower than any other values. * * @return {@code true} if {@code NULL} values are sorted low, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean nullsAreSortedLow() throws SQLException; /** * Determines whether deletes made by others are visible, for a specified {@code * ResultSet} type. * * @param type * the type of the {@code ResultSet}. It may be either {@code * ResultSet.TYPE_FORWARD_ONLY} or {@code * ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE}) * @return {@code true} if others' deletes are visible, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean othersDeletesAreVisible(int type) throws SQLException; /** * Determines whether inserts made by others are visible, for a specified {@code * ResultSet} type. * * @param type * the type of the {@code ResultSet}. May be {@code * ResultSet.TYPE_FORWARD_ONLY}, or {@code * ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} if others' inserts are visible, otherwise {@code * false}. * @throws SQLException * a database error occurred. */ public boolean othersInsertsAreVisible(int type) throws SQLException; /** * Determines whether updates made by others are visible, for a specified {@code * ResultSet} type. * * @param type * the type of the {@code ResultSet}. May be {@code * ResultSet.TYPE_FORWARD_ONLY}, or {@code * ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} if others' inserts are visible, otherwise {@code * false}. * @throws SQLException * a database error occurred. */ public boolean othersUpdatesAreVisible(int type) throws SQLException; /** * Determines whether a {@code ResultSet} can see its own deletes, for a * specified {@code ResultSet} type. * * @param type * the type of the {@code ResultSet}: {@code * ResultSet.TYPE_FORWARD_ONLY}, {@code * ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} if the deletes are seen by the {@code * ResultSet} itself, otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean ownDeletesAreVisible(int type) throws SQLException; /** * Determines whether a {@code ResultSet} can see its own inserts, for a * specified {@code ResultSet} type. * * @param type * the type of the {@code ResultSet}: {@code * ResultSet.TYPE_FORWARD_ONLY}, {@code * ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} if the inserts are seen by the {@code * ResultSet} itself, otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean ownInsertsAreVisible(int type) throws SQLException; /** * Determines whether a {@code ResultSet} can see its own updates, for a * specified {@code ResultSet} type. * * @param type * the type of the {@code ResultSet}: {@code * ResultSet.TYPE_FORWARD_ONLY}, {@code * ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} if the updates are seen by the {@code * ResultSet} itself, otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean ownUpdatesAreVisible(int type) throws SQLException; /** * Determines whether the database treats SQL identifiers that are in mixed * case (and unquoted) as case insensitive. If {@code true} then the * database stores them in lower case. * * @return {@code true} if unquoted SQL identifiers are stored in lower * case, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean storesLowerCaseIdentifiers() throws SQLException; /** * Determines whether the database considers mixed case quoted SQL * identifiers as case insensitive and stores them in lower case. * * @return {@code true} if quoted SQL identifiers are stored in lower case, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean storesLowerCaseQuotedIdentifiers() throws SQLException; /** * Determines whether the database considers mixed case unquoted SQL * identifiers as case insensitive and stores them in mixed case. * * @return {@code true} if unquoted SQL identifiers as stored in mixed case, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean storesMixedCaseIdentifiers() throws SQLException; /** * Determines whether the database considers identifiers as case insensitive * if they are mixed case quoted SQL. The database stores them in mixed * case. * * @return {@code true} if quoted SQL identifiers are stored in mixed case, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean storesMixedCaseQuotedIdentifiers() throws SQLException; /** * Determines whether the database considers mixed case unquoted SQL * identifiers as case insensitive and stores them in upper case. * * @return {@code true} if unquoted SQL identifiers are stored in upper * case, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean storesUpperCaseIdentifiers() throws SQLException; /** * Determines whether the database considers mixed case quoted SQL * identifiers as case insensitive and stores them in upper case. * * @return {@code true} if quoted SQL identifiers are stored in upper case, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean storesUpperCaseQuotedIdentifiers() throws SQLException; /** * Determines whether the database supports {@code ALTER TABLE} operation with * {@code ADD COLUMN}. * * @return {@code true} if {@code ALTER TABLE} with {@code ADD COLUMN} is * supported, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsAlterTableWithAddColumn() throws SQLException; /** * Determines whether the database supports {@code ALTER TABLE} operation with * {@code DROP COLUMN}. * * @return {@code true} if {@code ALTER TABLE} with {@code DROP COLUMN} is * supported, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsAlterTableWithDropColumn() throws SQLException; /** * Determines whether the database supports the ANSI92 entry level SQL grammar. * * @return {@code true} if the ANSI92 entry level SQL grammar is supported, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsANSI92EntryLevelSQL() throws SQLException; /** * Determines whether the database supports the ANSI92 full SQL grammar. * * @return {@code true} if the ANSI92 full SQL grammar is supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsANSI92FullSQL() throws SQLException; /** * Determines whether the database supports the ANSI92 intermediate SQL Grammar. * * @return {@code true} if the ANSI92 intermediate SQL grammar is supported, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsANSI92IntermediateSQL() throws SQLException; /** * Determines whether the database supports batch updates. * * @return {@code true} if batch updates are supported, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsBatchUpdates() throws SQLException; /** * Determines whether catalog names may be used in data manipulation * statements. * * @return {@code true} if catalog names can be used in data manipulation * statements, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsCatalogsInDataManipulation() throws SQLException; /** * Determines whether catalog names can be used in index definition statements. * * @return {@code true} if catalog names can be used in index definition * statements, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsCatalogsInIndexDefinitions() throws SQLException; /** * Determines whether catalog names can be used in privilege definition * statements. * * @return {@code true} if catalog names can be used in privilege definition * statements, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException; /** * Determines whether catalog names can be used in procedure call statements. * * @return {@code true} if catalog names can be used in procedure call * statements. * @throws SQLException * a database error occurred. */ public boolean supportsCatalogsInProcedureCalls() throws SQLException; /** * Determines whether catalog names may be used in table definition statements. * * @return {@code true} if catalog names can be used in definition * statements, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsCatalogsInTableDefinitions() throws SQLException; /** * Determines whether the database supports column aliasing. *

* If aliasing is supported, then the SQL AS clause is used to provide names * for computed columns and provide alias names for columns. * * @return {@code true} if column aliasing is supported, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsColumnAliasing() throws SQLException; /** * Determines whether the database supports the {@code CONVERT} operation between * SQL types. * * @return {@code true} if the {@code CONVERT} operation is supported, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsConvert() throws SQLException; /** * Determines whether the database supports {@code CONVERT} operation for two * supplied SQL types. * * @param fromType * the Type to convert from, as defined by {@code java.sql.Types} * @param toType * the Type to convert to, as defined by {@code java.sql.Types} * @return {@code true} if the {@code CONVERT} operation is supported for * these types, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsConvert(int fromType, int toType) throws SQLException; /** * Determines whether the database supports the Core SQL Grammar for ODBC. * * @return {@code true} if the Core SQL Grammar is supported, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsCoreSQLGrammar() throws SQLException; /** * Determines whether the database supports correlated sub-queries. * * @return {@code true} if the database does support correlated sub-queries * and {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsCorrelatedSubqueries() throws SQLException; /** * Determines whether the database allows both data definition and data * manipulation statements inside a transaction. * * @return {@code true} if both types of statement are permitted, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException; /** * Determines whether the database only allows data manipulation statements inside * a transaction. * * @return {@code true} if data manipulation statements are permitted only within a transaction, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsDataManipulationTransactionsOnly() throws SQLException; /** * Determines whether table correlation names are required to be different from * the names of the tables, when they are supported. * * @return {@code true} if correlation names must be different from table * names, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsDifferentTableCorrelationNames() throws SQLException; /** * Determines whether expressions in {@code ORDER BY} lists are supported. * * @return {@code true} if expressions in {@code ORDER BY} lists are * supported. * @throws SQLException * a database error occurred. */ public boolean supportsExpressionsInOrderBy() throws SQLException; /** * Determines whether the Extended SQL Grammar for ODBC is supported. * * @return {@code true} if the Extended SQL Grammar is supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsExtendedSQLGrammar() throws SQLException; /** * Determines whether the database supports full nested outer joins. * * @return {@code true} if full nested outer joins are supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsFullOuterJoins() throws SQLException; /** * Determines whether auto generated keys can be returned when a statement * executes. * * @return {@code true} if auto generated keys can be returned, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsGetGeneratedKeys() throws SQLException; /** * Determines whether the database supports {@code GROUP BY} clauses. * * @return {@code true} if the {@code GROUP BY} clause is supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsGroupBy() throws SQLException; /** * Determines whether the database supports using a column name in a {@code GROUP * BY} clause not included in the {@code SELECT} statement as long as all of * the columns in the {@code SELECT} statement are used in the {@code GROUP * BY} clause. * * @return {@code true} if {@code GROUP BY} clauses can use column names in * this way, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsGroupByBeyondSelect() throws SQLException; /** * Determines whether the database supports using a column name in a {@code GROUP * BY} clause that is not in the {@code SELECT} statement. * * @return {@code true} if {@code GROUP BY} clause can use a column name not * in the {@code SELECT} statement, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsGroupByUnrelated() throws SQLException; /** * Determines whether the database supports SQL Integrity Enhancement * Facility. * * @return {@code true} if the Integrity Enhancement Facility is supported, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsIntegrityEnhancementFacility() throws SQLException; /** * Determines whether the database supports a {@code LIKE} escape clause. * * @return {@code true} if LIKE escape clause is supported, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsLikeEscapeClause() throws SQLException; /** * Determines whether the database provides limited support for outer join * operations. * * @return {@code true} if there is limited support for outer join * operations, {@code false} otherwise. This will be {@code true} if * {@code supportsFullOuterJoins} returns {@code true}. * @throws SQLException * a database error occurred. */ public boolean supportsLimitedOuterJoins() throws SQLException; /** * Determines whether the database supports Minimum SQL Grammar for ODBC. * * @return {@code true} if the Minimum SQL Grammar is supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsMinimumSQLGrammar() throws SQLException; /** * Determines whether the database treats mixed case unquoted SQL identifiers as * case sensitive storing them in mixed case. * * @return {@code true} if unquoted SQL identifiers are stored in mixed * case, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsMixedCaseIdentifiers() throws SQLException; /** * Determines whether the database considers mixed case quoted SQL * identifiers as case sensitive, storing them in mixed case. * * @return {@code true} if quoted SQL identifiers are stored in mixed case, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException; /** * Determines whether it is possible for a single {@code CallableStatement} to * return multiple {@code ResultSet}s simultaneously. * * @return {@code true} if a single {@code CallableStatement} can return * multiple {@code ResultSet}s simultaneously, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsMultipleOpenResults() throws SQLException; /** * Determines whether retrieving multiple {@code ResultSet}s from a single * call to the {@code execute} method is supported. * * @return {@code true} if multiple {@code ResultSet}s can be retrieved, * {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsMultipleResultSets() throws SQLException; /** * Determines whether multiple simultaneous transactions on * different connections are supported. * * @return {@code true} if multiple open transactions are supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsMultipleTransactions() throws SQLException; /** * Determines whether callable statements with named parameters is supported. * * @return {@code true} if named parameters can be used with callable * statements, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsNamedParameters() throws SQLException; /** * Determines whether columns in the database can be defined as non-nullable. * * @return {@code true} if columns can be defined non-nullable, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsNonNullableColumns() throws SQLException; /** * Determines whether keeping cursors open across commit operations is * supported. * * @return {@code true} if cursors can be kept open across commit * operations, {@code false} if they might get closed. * @throws SQLException * a database error occurred. */ public boolean supportsOpenCursorsAcrossCommit() throws SQLException; /** * Determines whether the database can keep cursors open across rollback * operations. * * @return {@code true} if cursors can be kept open across rollback * operations, {@code false} if they might get closed. * @throws SQLException * a database error occurred. */ public boolean supportsOpenCursorsAcrossRollback() throws SQLException; /** * Determines whether keeping statements open across commit operations is * supported. * * @return {@code true} if statements can be kept open, {@code false} if * they might not. * @throws SQLException * a database error occurred. */ public boolean supportsOpenStatementsAcrossCommit() throws SQLException; /** * Determines whether keeping statements open across rollback operations is * supported. * * @return {@code true} if statements can be kept open, {@code false} if * they might not. * @throws SQLException * a database error occurred. */ public boolean supportsOpenStatementsAcrossRollback() throws SQLException; /** * Determines whether using a column in an {@code ORDER BY} clause that is * not in the {@code SELECT} statement is supported. * * @return {@code true} if it is possible to {@code ORDER} using a column * not in the {@code SELECT}, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsOrderByUnrelated() throws SQLException; /** * Determines whether outer join operations are supported. * * @return {@code true} if outer join operations are supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsOuterJoins() throws SQLException; /** * Determines whether positioned {@code DELETE} statements are supported. * * @return {@code true} if the database supports positioned {@code DELETE} * statements. * @throws SQLException * a database error occurred. */ public boolean supportsPositionedDelete() throws SQLException; /** * Determines whether positioned {@code UPDATE} statements are supported. * * @return {@code true} if the database supports positioned {@code UPDATE} * statements, {@code false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsPositionedUpdate() throws SQLException; /** * Determines whether there is support for a given concurrency style for the * given {@code ResultSet}. * * @param type * the {@code ResultSet} type, as defined in {@code * java.sql.ResultSet}: *

* @param concurrency * a concurrency type, which may be one of {@code * ResultSet.CONCUR_READ_ONLY} or {@code * ResultSet.CONCUR_UPDATABLE}. * @return {@code true} if that concurrency and {@code ResultSet} type * pairing is supported otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsResultSetConcurrency(int type, int concurrency) throws SQLException; /** * Determines whether the supplied {@code ResultSet} holdability mode is * supported. * * @param holdability * as specified in {@code java.sql.ResultSet}: {@code * ResultSet.HOLD_CURSORS_OVER_COMMIT} or {@code * ResultSet.CLOSE_CURSORS_AT_COMMIT} * @return {@code true} if the given ResultSet holdability is supported and * if it isn't then {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsResultSetHoldability(int holdability) throws SQLException; /** * Determines whether the supplied {@code ResultSet} type is supported. * * @param type * the {@code ResultSet} type as defined in {@code * java.sql.ResultSet}: {@code ResultSet.TYPE_FORWARD_ONLY}, * {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} if the {@code ResultSet} type is supported, {@code * false} otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsResultSetType(int type) throws SQLException; /** * Determines whether savepoints for transactions are supported. * * @return {@code true} if savepoints are supported, {@code false} * otherwise. * @throws SQLException * a database error occurred. */ public boolean supportsSavepoints() throws SQLException; /** * Determines whether a schema name may be used in a data manipulation * statement. * * @return {@code true} if a schema name can be used in a data manipulation, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSchemasInDataManipulation() throws SQLException; /** * Determines whether a schema name may be used in an index definition * statement. * * @return {@code true} if a schema name can be used in an index definition, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSchemasInIndexDefinitions() throws SQLException; /** * Determines whether a database schema name can be used in a privilege * definition statement. * * @return {@code true} if a database schema name may be used in a privilege * definition, otherwise {@code false} * @throws SQLException * a database error occurred. */ public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException; /** * Determines whether a procedure call statement may be contain in a schema name. * * @return {@code true} if a schema name can be used in a procedure call, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSchemasInProcedureCalls() throws SQLException; /** * Determines whether a schema name can be used in a table definition statement. * * @return {@code true} if a schema name can be used in a table definition, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSchemasInTableDefinitions() throws SQLException; /** * Determines whether the {@code SELECT FOR UPDATE} statement is supported. * * @return {@code true} if {@code SELECT FOR UPDATE} statements are * supported, otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSelectForUpdate() throws SQLException; /** * Determines whether statement pooling is supported. * * @return {@code true} of the database does support statement pooling, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsStatementPooling() throws SQLException; /** * Determines whether stored procedure calls using the stored procedure * escape syntax is supported. * * @return {@code true} if stored procedure calls using the stored procedure * escape syntax are supported, otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsStoredProcedures() throws SQLException; /** * Determines whether subqueries in comparison expressions are supported. * * @return {@code true} if subqueries are supported in comparison * expressions. * @throws SQLException * a database error occurred. */ public boolean supportsSubqueriesInComparisons() throws SQLException; /** * Determines whether subqueries in {@code EXISTS} expressions are supported. * * @return {@code true} if subqueries are supported in {@code EXISTS} * expressions, otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSubqueriesInExists() throws SQLException; /** * Determines whether subqueries in {@code IN} statements are supported. * * @return {@code true} if subqueries are supported in {@code IN} statements, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSubqueriesInIns() throws SQLException; /** * Determines whether subqueries in quantified expressions are supported. * * @return {@code true} if subqueries are supported, otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsSubqueriesInQuantifieds() throws SQLException; /** * Determines whether the database has table correlation names support. * * @return {@code true} if table correlation names are supported, otherwise * {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsTableCorrelationNames() throws SQLException; /** * Determines whether a specified transaction isolation level is supported. * * @param level * the transaction isolation level, as specified in {@code * java.sql.Connection}: {@code TRANSACTION_NONE}, {@code * TRANSACTION_READ_COMMITTED}, {@code * TRANSACTION_READ_UNCOMMITTED}, {@code * TRANSACTION_REPEATABLE_READ}, {@code TRANSACTION_SERIALIZABLE} * @return {@code true} if the specific isolation level is supported, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsTransactionIsolationLevel(int level) throws SQLException; /** * Determines whether transactions are supported. *

* If transactions are not supported, then the {@code commit} method does * nothing and the transaction isolation level is always {@code * TRANSACTION_NONE}. * * @return {@code true} if transactions are supported, otherwise {@code * false}. * @throws SQLException * a database error occurred. */ public boolean supportsTransactions() throws SQLException; /** * Determines whether the {@code SQL UNION} operation is supported. * * @return {@code true} of the database does support {@code UNION}, otherwise * {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsUnion() throws SQLException; /** * Determines whether the {@code SQL UNION ALL} operation is supported. * * @return {@code true} if the database does support {@code UNION ALL}, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean supportsUnionAll() throws SQLException; /** * Determines whether the method {@code ResultSet.rowUpdated} can detect a visible * row update for the specified {@code ResultSet} type. * * @param type * {@code ResultSet} type: {@code ResultSet.TYPE_FORWARD_ONLY}, * {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or {@code * ResultSet.TYPE_SCROLL_SENSITIVE} * @return {@code true} detecting changes is possible, otherwise {@code * false}. * @throws SQLException * a database error occurred. */ public boolean updatesAreDetected(int type) throws SQLException; /** * Determines whether this database uses a file for each table. * * @return {@code true} if the database uses one file for each table, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean usesLocalFilePerTable() throws SQLException; /** * Determines whether this database uses a local file to store tables. * * @return {@code true} if the database stores tables in a local file, * otherwise {@code false}. * @throws SQLException * a database error occurred. */ public boolean usesLocalFiles() throws SQLException; /** * Determine if a SQLException while autoCommit is true indicates that all * open ResultSets are closed, even ones that are holdable * * @return true if all open ResultSets are closed * @throws SQLException * if any error occurs */ boolean autoCommitFailureClosesAllResultSets() throws SQLException; /** * Returns a list of the client info properties of the driver. * * @return a list of the client info * @throws SQLException * if any error occurs */ ResultSet getClientInfoProperties() throws SQLException; /** * Returns a description according to the given catalog's system or user * function parameters and return type. * * @param catalog * the given catalong * @param schemaPattern * the schema pattern * @param functionNamePattern * the function name pattern * @param columnNamePattern * the column name pattern * @return a description of user functions * @throws SQLException * if any error occurs */ ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException; /** * Returns a description of the system and user functions available * according to the given catalog. * * @param catalog * the given catalog * @param schemaPattern * the schema pattern * @param functionNamePattern * the function name pattern * @return user functions * @throws SQLException * if any error occurs */ ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern) throws SQLException; /** * Returns the lifetime for which a RowId object remains valid if this data * source supports the SQL ROWID type * * @return the time of a RowId object that remains valid. * @throws SQLException * if any error occurs */ RowIdLifetime getRowIdLifetime() throws SQLException; /** * Returns the schema names ordered by TABLE_CATALOG and TABLE_SCHEMA. * * @param catalog * the catalog * @param schemaPattern * the schema pattern * @return the schema names * @throws SQLException * if any error occurs */ ResultSet getSchemas(String catalog, String schemaPattern) throws SQLException; /** * Determine if this database supports invoking user-defined or vendor * functions using the stored procedure escape syntax. * * @return true if this database supports invoking user-defined or vendor * functions using the stored procedure escape syntax. * @throws SQLException * if any error occurs */ boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException; }