org.modeshape.connector.meta.jdbc

## Interface MetadataCollector

- All Known Implementing Classes:
    JdbcMetadataCollector, SqlServerMetadataCollector

      public interface MetadataCollector

  The `MetadataCollector` provides hooks for DBMS-specific implementations of metadata retrieval methods. These methods largely duplicate what is provided in `the JDBC metadata interface`, but allow a pluggable way to work around JDBC driver-specific shortcomings.

  For convenience, a `JdbcMetadataCollector` default implementation} of this interface is provided that is based on `DatabaseMetaData`.

  See Also:
    `JdbcMetadataCollector`

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `List<String>` | `getCatalogNames(Connection conn)` Return the list of catalog names that currently exist in the database to which `connection` is connected.
    `List<ColumnMetadata>` | `getColumns(Connection conn, String catalogName, String schemaName, String tableName, String columnName)` Return the list of columns that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null), named schema (if `schemaName` is non-null), and named table.
    `DBMetadata` | `getDatabaseMetadata(Connection conn)` Return metadata information about the database to which `connection` is connected.
    `List<ForeignKeyMetadata>` | `getForeignKeys(Connection conn, String catalogName, String schemaName, String tableName, String fkColumnName)` Return the list of foreign keys import by a table that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null), named schema (if `schemaName` is non-null), and named table.
    `List<ProcedureMetadata>` | `getProcedures(Connection conn, String catalogName, String schemaName, String procedureName)` Return the list of procedures that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null) and named schema (if `schemaName` is non-null).
    `List<String>` | `getSchemaNames(Connection conn, String catalogName)` Return the list of schema names that currently exist in the database to which `connection` is connected within the named catalog.
    `List<TableMetadata>` | `getTables(Connection conn, String catalogName, String schemaName, String tableName)` Return the list of tables that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null) and named schema (if `schemaName` is non-null).

- - ### Method Detail

    - #### getDatabaseMetadata

          DBMetadata getDatabaseMetadata(Connection conn)
                                         throws JdbcMetadataException

      Return metadata information about the database to which `connection` is connected.
      Parameters:
        `conn` - the connection to the database; must not be non-null and must be open. This connection should not be closed by this method.
      Returns:
        An `DBMetadata` instance, never `null`
      Throws:
        `JdbcMetadataException` - if the metadata cannot be retrieved

    - #### getCatalogNames

          List<String> getCatalogNames(Connection conn)
                                       throws JdbcMetadataException

      Return the list of catalog names that currently exist in the database to which `connection` is connected. The names must be sorted in a manner that is stable between successive calls to this method.
      Parameters:
        `conn` - the connection to the database; must not be non-null and must be open. This connection should not be closed by this method.
      Returns:
        An ordered list of the catalogs in the database, or an empty list if no catalogs exist; may not be null
      Throws:
        `JdbcMetadataException` - if the catalog names cannot be retrieved
      See Also:
        `DatabaseMetaData.getCatalogs()`

    - #### getSchemaNames

          List<String> getSchemaNames(Connection conn,
                                    String catalogName)
                                      throws JdbcMetadataException

      Return the list of schema names that currently exist in the database to which `connection` is connected within the named catalog. If `catalogName` is null, then all schema names should be returned regardless of the catalog with which they are associated. The schema names must be sorted in a manner that is stable between successive calls to this method.
      Parameters:
        `conn` - the connection to the database; must not be non-null and must be open. This connection should not be closed by this method.
        `catalogName` - the name of the catalog to which returned schemas must belong, or null if all schemas are to be returned
      Returns:
        An ordered list of the schemas in the database, or an empty list if no schemas exist; may not be null
      Throws:
        `JdbcMetadataException` - if the schema names cannot be retrieved
      See Also:
        `DatabaseMetaData.getSchemas()`

    - #### getTables

          List<TableMetadata> getTables(Connection conn,
                                      String catalogName,
                                      String schemaName,
                                      String tableName)
                                        throws JdbcMetadataException

      Return the list of tables that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null) and named schema (if `schemaName` is non-null). If `tableName` is null, then all tables which conform to the catalog and schema restriction noted previously should be returned. If `tableName` is non-null, then only the table(s) that exactly match that name should be returned. The table metadata must be sorted in a manner that is stable between successive calls to this method.
      Parameters:
        `conn` - the connection to the database; must not be non-null and must be open. This connection should not be closed by this method.
        `catalogName` - the name of the catalog to which returned tables must belong, or null if tables are to be returned without regard to their catalog
        `schemaName` - the name of the schema to which returned tables must belong, or null if tables are to be returned without regard to their schema
        `tableName` - the name of the table to be returned, or null if all tables within the given catalog and schema are to be returned
      Returns:
        An ordered list of the tables in the database that match the given constraints, or an empty list if no tables exist that match the given constraints; may not be null
      Throws:
        `JdbcMetadataException` - if the table metadata cannot be retrieved
      See Also:
        `DatabaseMetaData.getTables(String, String, String, String[])`

    - #### getColumns

          List<ColumnMetadata> getColumns(Connection conn,
                                        String catalogName,
                                        String schemaName,
                                        String tableName,
                                        String columnName)
                                          throws JdbcMetadataException

      Return the list of columns that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null), named schema (if `schemaName` is non-null), and named table. If `columnName` is null, then all columns which conform to the catalog, schema, and table restrictions noted previously should be returned. If `columnName` is non-null, then only the column that exactly matches that name should be returned. The column metadata must be sorted in a manner that is stable between successive calls to this method.
      Parameters:
        `conn` - the connection to the database; must not be non-null and must be open. This connection should not be closed by this method.
        `catalogName` - the name of the catalog to which returned columns must belong, or null if columns are to be returned without regard to their catalog
        `schemaName` - the name of the schema to which returned columns must belong, or null if columns are to be returned without regard to their schema
        `tableName` - the name of the table to which returned columns must belong; may not be null
        `columnName` - the name of the column to be returned, or null if all columns within the given catalog, schema, and table are to be returned
      Returns:
        An ordered list of the columns in the database that match the given constraints, or an empty list if no columns exist that match the given constraints; may not be null
      Throws:
        `JdbcMetadataException` - if the column metadata cannot be retrieved
      See Also:
        `DatabaseMetaData.getColumns(String, String, String, String)`

    - #### getProcedures

          List<ProcedureMetadata> getProcedures(Connection conn,
                                              String catalogName,
                                              String schemaName,
                                              String procedureName)
                                                throws JdbcMetadataException

      Return the list of procedures that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null) and named schema (if `schemaName` is non-null). If `procedureName` is null, then all procedures which conform to the catalog and schema restriction noted previously should be returned. If `procedureName` is non-null, then only the procedure(s) that exactly match that name should be returned. The procedure metadata must be sorted in a manner that is stable between successive calls to this method.
      Parameters:
        `conn` - the connection to the database; must not be non-null and must be open. This connection should not be closed by this method.
        `catalogName` - the name of the catalog to which returned procedures must belong, or null if procedures are to be returned without regard to their catalog
        `schemaName` - the name of the schema to which returned procedures must belong, or null if procedures are to be returned without regard to their schema
        `procedureName` - the name of the procedure(s) to be returned, or null if all procedures within the given catalog and schema are to be returned
      Returns:
        An ordered list of the procedures in the database that match the given constraints, or an empty list if no procedures exist that match the given constraints; may not be null
      Throws:
        `JdbcMetadataException` - if the procedure metadata cannot be retrieved

    - #### getForeignKeys

          List<ForeignKeyMetadata> getForeignKeys(Connection conn,
                                                String catalogName,
                                                String schemaName,
                                                String tableName,
                                                String fkColumnName)
                                                  throws JdbcMetadataException

      Return the list of foreign keys import by a table that currently exist in the database to which `connection` is connected within the named catalog (if `catalogName` is non-null), named schema (if `schemaName` is non-null), and named table.
      Parameters:
        `conn` - the connection to the database; must not be non-null and must be open. This connection should not be closed by this method.
        `catalogName` - the name of the catalog to which returned columns must belong, or null if columns are to be returned without regard to their catalog
        `schemaName` - the name of the schema to which returned columns must belong, or null if columns are to be returned without regard to their schema
        `tableName` - the name of the table to which returned columns must belong; may not be null
        `fkColumnName` - the name of the foreign key column for which to retrieve metadata; may be null. If that is the case, all the foreign keys will be retrieved.
      Returns:
        An ordered list of the foreign keys that are exported by the given table, or an empty list if no columns exist that match the given constraints; may not be null
      Throws:
        `JdbcMetadataException` - if the column metadata cannot be retrieved
      See Also:
        `DatabaseMetaData.getImportedKeys(String, String, String)`

Copyright © 2008-2014 JBoss, a division of Red Hat. All Rights Reserved.