harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r770130 [4/10] - in /harmony/enhanced/classlib/trunk/modules/sql/src/main/java: java/sql/ javax/sql/
Date Thu, 30 Apr 2009 09:45:42 GMT
Modified: harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DatabaseMetaData.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DatabaseMetaData.java?rev=770130&r1=770129&r2=770130&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DatabaseMetaData.java (original)
+++ harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/DatabaseMetaData.java Thu Apr 30 09:45:40 2009
@@ -18,34 +18,35 @@
 package java.sql;
 
 /**
- * An interface which provides comprehensive information about the database.
+ * An interface which provides comprehensive information about the database
+ * management system and its supported features.
  * <p>
- * This interface is implemented by JDBC driver writers in order to provide
- * information about the underlying Database capabilities and the JDBC driver
- * capabilities taken together.
+ * This interface is implemented by JDBC driver vendors in order to provide
+ * information about the underlying database capabilities in association with
+ * the JDBC driver.
  * <p>
- * Some of the methods in this interface take String parameters which are
- * Patterns. Within these string Patterns, '%' and '_' characters have special
- * meanings. '%' means "match any substring of 0 or more characters". '_' means
- * "match any one character". Only metadata entries that match the pattern are
- * returned. If such a search pattern string is set to <code>null</code>,
- * that argument's criteria are dropped from the search.
- * 
+ * 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 {
 
     /**
-     * States that it may not be permitted to store <code>NULL</code> values.
+     * States that it may not be permitted to store {@code NULL} values.
      */
     public static final short attributeNoNulls = 0;
 
     /**
-     * States that <code>NULL</code> values are definitely permitted.
+     * States that {@code NULL} values are definitely permitted.
      */
     public static final short attributeNullable = 1;
 
     /**
-     * States that whether <code>NULL</code> values are permitted is unknown.
+     * States that whether {@code NULL} values are permitted is unknown.
      */
     public static final short attributeNullableUnknown = 2;
 
@@ -83,12 +84,12 @@
     public static final int bestRowUnknown = 0;
 
     /**
-     * States that the column might not allow <code>NULL</code> values.
+     * States that the column must not allow {@code NULL} values.
      */
     public static final int columnNoNulls = 0;
 
     /**
-     * States that the column definitely allows <code>NULL</code> values.
+     * States that the column definitely allows {@code NULL} values.
      */
     public static final int columnNullable = 1;
 
@@ -98,69 +99,72 @@
     public static final int columnNullableUnknown = 2;
 
     /**
-     * For the column UPDATE_RULE, States that when the primary key is updated,
-     * the foreign key (imported key) is changed to agree with it.
+     * 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 deferrability.
+     * States that the evaluation of foreign key constraints is deferred (delayed
+     * until commit).
      */
     public static final int importedKeyInitiallyDeferred = 5;
 
     /**
-     * States defer-ability.
+     * States that the evaluation of foreign key constraint is {@code IMMEDIATE}
+     * .
      */
     public static final int importedKeyInitiallyImmediate = 6;
 
     /**
-     * For the columns UPDATE_RULE and DELETE_RULE, States that if the primary
-     * key has been imported, it cannot be updated or deleted.
+     * 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 defer-ability.
+     * 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 UPDATE_RULE.
+     * 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
-     * UPDATE_RULE and DELETE_RULE columns.
+     * {@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</code>. Applies to the
-     * UPDATE_RULE and DELETE_RULE columns.
+     * 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 this column stores IN type parameters.
+     * States that the column stores {@code IN} type parameters.
      */
     public static final int procedureColumnIn = 1;
 
     /**
-     * States that this column stores INOUT type parameters.
+     * States that this column stores {@code INOUT} type parameters.
      */
     public static final int procedureColumnInOut = 2;
 
     /**
-     * States that this column stores OUT type parameters.
+     * States that this column stores {@code OUT} type parameters.
      */
     public static final int procedureColumnOut = 4;
 
     /**
-     * States that the column stores results
+     * States that the column stores results.
      */
     public static final int procedureColumnResult = 3;
 
@@ -175,7 +179,7 @@
     public static final int procedureColumnUnknown = 0;
 
     /**
-     * States that <code>NULL</code> values are not permitted.
+     * States that {@code NULL} values are not permitted.
      */
     public static final int procedureNoNulls = 0;
 
@@ -185,12 +189,12 @@
     public static final int procedureNoResult = 1;
 
     /**
-     * States that <code>NULL</code> values are permitted.
+     * States that {@code NULL} values are permitted.
      */
     public static final int procedureNullable = 1;
 
     /**
-     * States that whether <code>NULL</code> values are permitted is unknown.
+     * States that it is unknown whether {@code NULL} values are permitted.
      */
     public static final int procedureNullableUnknown = 2;
 
@@ -205,13 +209,13 @@
     public static final int procedureReturnsResult = 2;
 
     /**
-     * States that the value is an SQL99 SQLSTATE value.
+     * States that the value is an SQL99 {@code SQLSTATE} value.
      */
     public static final int sqlStateSQL99 = 2;
 
     /**
-     * States that the value is an SQL CLI SQLSTATE value as defined by X/Open
-     * (who are now know as Open Group) .
+     * States that the value is an SQL {@code CLI SQLSTATE} value as defined by
+     * the X/Open standard.
      */
     public static final int sqlStateXOpen = 1;
 
@@ -238,41 +242,41 @@
     public static final short tableIndexStatistic = 0;
 
     /**
-     * States that a <code>NULL</code> value is <em>NOT</em> permitted for
+     * States that a {@code NULL} value is <em>NOT</em> permitted for
      * this data type.
      */
     public static final int typeNoNulls = 0;
 
     /**
-     * States that a <code>NULL</code> value is permitted for this data type.
+     * 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</code> value is permitted for
+     * States that it is unknown if a {@code NULL} value is permitted for
      * this data type.
      */
     public static final int typeNullableUnknown = 2;
 
     /**
-     * States that one can base all WHERE search clauses except WHERE .
+     * 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 <code>WHERE</code> is the only WHERE search clause that may
-     * be based on this type.
+     * States that this column can only be used in a {@code WHERE...LIKE}
+     * statement.
      */
     public static final int typePredChar = 1;
 
     /**
-     * States that this type does not support <code>WHERE</code> search
-     * clauses.
+     * States that this column does not support searches.
      */
     public static final int typePredNone = 0;
 
     /**
-     * States that all WHERE search clauses may be based on this type.
+     * States that the column is searchable.
      */
     public static final int typeSearchable = 3;
 
@@ -292,668 +296,659 @@
     public static final int versionColumnUnknown = 0;
 
     /**
-     * Answers whether all procedures returned by <code>getProcedures</code>
-     * can be called by the current user.
+     * Returns whether all procedures returned by {@link #getProcedures} can be
+     * called by the current user.
      * 
-     * @return <code>true</code> if all procedures can be called by the
-     *         current user, <code>false</code> otherwise.
+     * @return {@code true} if all procedures can be called by the current user,
+     *         {@code false} otherwise.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public boolean allProceduresAreCallable() throws SQLException;
 
     /**
-     * Answers whether all the tables returned by <code>getTables</code> can
-     * be used by the current user in a SELECT statement.
+     * Returns whether all the tables returned by {@code getTables} can be used
+     * by the current user in a {@code SELECT} statement.
      * 
-     * @return <code>true</code> if all the tables can be used,<code>false</code>
-     *         otherwise
+     * @return {@code true} if all the tables can be used,{@code false}
+     *         otherwise.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public boolean allTablesAreSelectable() throws SQLException;
 
     /**
-     * Answers if a data definition statement in a transaction forces a commit
-     * of the transaction.
+     * Returns whether a data definition statement in a transaction forces a {@code
+     * commit} of the transaction.
      * 
-     * @return <code>true</code> if the statement forces a commit,
-     *         <code>false</code> otherwise
+     * @return {@code true} if the statement forces a commit, {@code false}
+     *         otherwise.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public boolean dataDefinitionCausesTransactionCommit() throws SQLException;
 
     /**
-     * Answers whether the database ignores data definition statements within a
+     * Returns whether the database ignores data definition statements within a
      * transaction.
      * 
-     * @return <code>true</code> if the database ignores a data definition
-     *         statement, <code>false</code> otherwise
+     * @return {@code true} if the database ignores a data definition statement,
+     *         {@code false} otherwise.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public boolean dataDefinitionIgnoredInTransactions() throws SQLException;
 
     /**
-     * Answers whether a visible row delete can be detected by calling
-     * <code>ResultSet.rowDeleted</code>.
+     * Returns whether a visible row delete can be detected by calling
+     * {@link ResultSet#rowDeleted}.
      * 
      * @param type
-     *            the type of the ResultSet involved:
-     *            <code>ResultSet.TYPE_FORWARD_ONLY</code>,
-     *            <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
-     *            <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
-     * @return <code>true</code> if the visible row delete can be detected,
-     *         <code>false</code> otherwise
+     *            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
+     *             if there is a database error.
      */
     public boolean deletesAreDetected(int type) throws SQLException;
 
     /**
-     * Answers whether the return value of <code>getMaxRowSize</code> includes
-     * the SQL data types <code>LONGVARCHAR</code> and
-     * <code>LONGVARBINARY</code>.
-     * 
-     * @return <code>true</code> if the return value includes
-     *         <code>LONGVARBINARY</code> and <code>LONGVARCHAR</code>,
-     *         otherwise <code>false</code>.
+     * 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
+     *             if there is a database error.
      */
     public boolean doesMaxRowSizeIncludeBlobs() throws SQLException;
 
     /**
-     * Answers a description of the specified attribute of the specified type
-     * for an SQL User Defined Type (UDT) for a specified schema and catalog.
-     * The descriptions returned are ordered by <code>TYPE_SCHEM</code>,
-     * <code>TYPE_NAME</code> and ORDINAL_POSITION. The descriptions do not
-     * contain inherited attributes.
+     * 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.
      * <p>
-     * The returned ResultSet object has rows with the following column names
-     * and meanings:
+     * The columns of the returned {@code ResultSet} object have the following
+     * names and meanings:
      * <ol>
-     * <li><code>TYPE_CAT</code> - String - the Type Catalog name (possibly
-     * <code>null</code>)</li>
-     * <li><code>TYPE_SCHEM</code> - String - the Type Schema name (possibly
-     * <code>null</code>)</li>
-     * <li><code>TYPE_NAME</code> - String - the Type name</li>
-     * <li><code>ATTR_NAME</code> - String - the Attribute name</li>
-     * <li><code>DATA_TYPE</code> - int - the Attribute type as defined in
-     * <code>java.sql.Types</code></li>
-     * <li><code>ATTR_TYPE_NAME</code> - String - the Attribute type name.
-     * This depends on the data source. For a <code>UDT</code> the name is
-     * fully qualified. For a <code>REF</code> it is both fully qualified and
-     * represents the target type of the reference.</li>
-     * <li><code>ATTR_SIZE</code> - 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.</li>
-     * <li><code>DECIMAL_DIGITS</code> - int - how many fractional digits are
+     * <li>{@code TYPE_CAT} - String - the type catalog name (possibly {@code
+     * null})</li>
+     * <li>{@code TYPE_SCHEM} - String - the type schema name (possibly {@code
+     * null})</li>
+     * <li>{@code TYPE_NAME} - String - the type name</li>
+     * <li>{@code ATTR_NAME} - String - the attribute name</li>
+     * <li>{@code DATA_TYPE} - int - the attribute type as defined in {@code
+     * java.sql.Types}</li>
+     * <li>{@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.</li>
+     * <li>{@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.</li>
+     * <li>{@code DECIMAL_DIGITS} - int - how many fractional digits are
      * supported</li>
-     * <li><code>NUM_PREC_RADIX</code> - int - numeric values radix</li>
-     * <li><code>NULLABLE</code> - int - whether <code>NULL</code> is
-     * permitted:
+     * <li>{@code NUM_PREC_RADIX} - int - numeric values radix</li>
+     * <li>{@code NULLABLE} - int - whether {@code NULL} is permitted:
      * <ul>
-     * <li>DatabaseMetaData.attributeNoNulls - might not allow
-     * <code>NULL</code>s</li>
-     * <li>DatabaseMetaData.attributeNullable - <code>NULL</code>s
-     * definitely permitted</li>
+     * <li>DatabaseMetaData.attributeNoNulls - {@code NULL} values not permitted</li>
+     * <li>DatabaseMetaData.attributeNullable - {@code NULL} values definitely
+     * permitted</li>
      * <li>DatabaseMetaData.attributeNullableUnknown - unknown</li>
      * </ul>
      * </li>
-     * <li><code>REMARKS</code> - String - A comment describing the attribute
-     * (possibly <code>null</code>)</li>
-     * <li>ATTR_DEF - String - Default value for the attribute (possibly
-     * <code>null</code>)</li>
-     * <li><code>SQL_DATA_TYPE</code> - int - not used</li>
+     * <li>{@code REMARKS} - String - a comment describing the attribute
+     * (possibly {@code null})</li>
+     * <li>ATTR_DEF - String - Default value for the attribute (possibly {@code
+     * null})</li>
+     * <li>{@code SQL_DATA_TYPE} - int - not used</li>
      * <li>SQL_DATETIME_SUB - int - not used</li>
-     * <li>CHAR_OCTET_LENGTH - int - For <code>CHAR</code> types, the max
-     * number of bytes in the column</li>
-     * <li>ORDINAL_POSITION - int - The Index of the column in the Table (based
-     * on 1)</li>
-     * <li>IS_NULLABLE - String - "NO" = column does not allow
-     * <code>NULL</code>s, "YES" = column allows <code>NULL</code>s "" =
-     * <code>NULL</code> status unknown</li>
-     * <li><code>SCOPE_CATALOG</code> - String - Catalog for table,
-     * <code>SCOPE</code> of Reference attribute. NULL if
-     * <code>DATA_TYPE</code> is not REF.</li>
-     * <li><code>SCOPE_SCHEMA</code> - String - Schema for table,
-     * <code>SCOPE</code> of Reference attribute. NULL if
-     * <code>DATA_TYPE</code> is not REF.</li>
-     * <li><code>SCOPE_TABLE</code> - String - Table name for
-     * <code>SCOPE</code> of Reference attribute. <code>NULL</code> if
-     * <code>DATA_TYPE</code> is not REF.</li>
-     * <li><code>SOURCE_DATA_TYPE</code> - String - The source type for user
-     * generated REF type or for a Distinct type. (<code>NULL</code> if
-     * <code>DATA_TYPE</code> is not DISTINCT or user generated REF)</li>
+     * <li>CHAR_OCTET_LENGTH - int - for {@code CHAR} types, the max number of
+     * bytes in the column</li>
+     * <li>ORDINAL_POSITION - int - The index of the column in the table (where
+     * the count starts from 1, not 0)</li>
+     * <li>IS_NULLABLE - String - {@code "NO"} = the column does not allow {@code
+     * NULL}s, {@code "YES"} = the column allows {@code NULL}s, "" = status unknown</li>
+     * <li>{@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.</li>
+     * <li>{@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.</li>
+     * <li>{@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.</li>
+     * <li>{@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)</li>
      * </ol>
-     * 
+     *
      * @param catalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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</code> 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.
+     *            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
+     *            a type name. This pattern must match the type name stored in
      *            the database.
      * @param attributeNamePattern
-     *            an Attribute name. Must match the attribute name as stored in
+     *            an Attribute name. This pattern must match the attribute name as stored in
      *            the database.
-     * @return a ResultSet, where each Row is an attribute description
+     * @return a {@code ResultSet}, where each row is an attribute description.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public ResultSet getAttributes(String catalog, String schemaPattern,
             String typeNamePattern, String attributeNamePattern)
             throws SQLException;
 
     /**
-     * Answers a list of a table's optimal set of columns that uniquely
-     * identifies a row. The results are ordered by <code>SCOPE</code> (see
-     * below).
+     * 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).
      * <p>
      * The results are returned as a table, with one entry for each column, as
      * follows:
      * <ol>
-     * <li><code>SCOPE</code> - short - the <code>SCOPE</code> of the
-     * result, as follows:
+     * <li>{@code SCOPE} - short - the {@code SCOPE} of the result, as follows:
      * <ul>
-     * <li>DatabaseMetaData.bestRowTemporary - very temporary, while using row
-     * </li>
-     * <li>DatabaseMetaData.bestRowTransaction - good for remainder of current
-     * transaction </li>
-     * <li>DatabaseMetaData.bestRowSession - good for remainder of database
-     * session </li>
+     * <li>{@code DatabaseMetaData.bestRowTemporary} - the result is very temporary, 
+     * only valid while on the current row</li>
+     * <li>{@code DatabaseMetaData.bestRowTransaction} - the result is good for remainder of
+     * current transaction</li>
+     * <li>{@code DatabaseMetaData.bestRowSession} - the result is good for remainder of
+     * database session</li>
      * </ul>
      * </li>
-     * <li><code>COLUMN_NAME</code> - String - the column name </li>
-     * <li><code>DATA_TYPE</code> - int - the Type of the data, as defined in
-     * <code>java.sql.Types</code> </li>
-     * <li><code>TYPE_NAME</code> - String - Name of the type - database
-     * dependent. For UDT types the name is fully qualified </li>
-     * <li><code>COLUMN_SIZE</code> - int - The precision of the data in the
-     * column </li>
-     * <li><code>BUFFER_LENGTH</code> - int - not used </li>
-     * <li><code>DECIMAL_DIGITS</code> - short - number of fractional digits
-     * </li>
-     * <li><code>PSEUDO_COLUMN</code> - short - whether this is a pseudo
-     * column eg. and Oracle ROWID:
+     * <li>{@code COLUMN_NAME} - String - the column name</li>
+     * <li>{@code DATA_TYPE} - int - the Type of the data, as defined in {@code
+     * java.sql.Types}</li>
+     * <li>{@code TYPE_NAME} - String - the Name of the type - database dependent.
+     * For UDT types the name is fully qualified</li>
+     * <li>{@code COLUMN_SIZE} - int - the precision of the data in the column</li>
+     * <li>{@code BUFFER_LENGTH} - int - not used</li>
+     * <li>{@code DECIMAL_DIGITS} - short - number of fractional digits</li>
+     * <li>{@code PSEUDO_COLUMN} - short - whether this is a pseudo column (e.g.
+     * an Oracle {@code ROWID}):
      * <ul>
-     * <li>DatabaseMetaData.bestRowUnknown - don't know whether this is a
-     * pseudo column</li>
-     * <li>DatabaseMetaData.bestRowNotPseudo - column is not pseudo</li>
-     * <li>DatabaseMetaData.bestRowPseudo - column is a pseudo column</li>
+     * <li>{@code DatabaseMetaData.bestRowUnknown} - it is not known whether this is
+     * a pseudo column</li>
+     * <li>{@code DatabaseMetaData.bestRowNotPseudo} - the column is not pseudo</li>
+     * <li>{@code DatabaseMetaData.bestRowPseudo} - the column is a pseudo column</li>
      * </ul>
      * </li>
      * </ol>
-     * 
+     *
      * @param catalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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</code> 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.
+     *            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</code> of interest, values as defined above
+     *            the {@code SCOPE} of interest, values as defined above.
      * @param nullable
-     *            <code>true</code> = include columns that are nullable,
-     *            <code>false</code> = do not include
-     * @return a ResultSet where each row is a description of a column and the
-     *         complete set of rows is the optimal set for this table.
+     *            {@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
+     *             if there is a database error.
      */
     public ResultSet getBestRowIdentifier(String catalog, String schema,
             String table, int scope, boolean nullable) throws SQLException;
 
     /**
-     * Answers the set of catalog names available in this database. The set is
+     * Returns the set of catalog names available in this database. The set is
      * returned ordered by catalog name.
      * 
-     * @return a ResultSet containing the Catalog names, with each row
-     *         containing one Catalog name contained as a String in the single
-     *         column named <code>TABLE_CAT</code>.
+     * @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
+     *             if there is a database error.
      */
     public ResultSet getCatalogs() throws SQLException;
 
     /**
-     * Answers the separator that this database uses between a catalog name and
+     * Returns the separator that this database uses between a catalog name and
      * table name.
      * 
-     * @return a String containing the separator
+     * @return a String containing the separator.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public String getCatalogSeparator() throws SQLException;
 
     /**
-     * Answers the term that the database vendor prefers term for "catalog".
+     * Returns the term that the database vendor prefers term for "catalog".
      * 
-     * @return a String with the vendor's term for "catalog"
+     * @return a String with the vendor's term for "catalog".
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public String getCatalogTerm() throws SQLException;
 
     /**
-     * Answers a description of access rights for a table's columns. Only access
+     * Returns a description of access rights for a table's columns. Only access
      * rights matching the criteria for the column name are returned.
      * <p>
-     * The description is returned as a ResultSet with rows of data for each
-     * access right, with columns as follows:
+     * The description is returned as a {@code ResultSet} with rows of data for
+     * each access right, with columns as follows:
      * <ol>
-     * <li><code>TABLE_CAT</code> - String - Catalog name (possibly
-     * <code>null</code>)</li>
-     * <li><code>TABLE_SCHEM</code> - String - Schema name (possibly
-     * <code>null</code>) </li>
-     * <li><code>TABLE_NAME</code> - String - The Table name </li>
-     * <li><code>COLUMN_NAME</code> - String - The Column name</li>
-     * <li><code>GRANTOR</code> - String - The grantor of access (possibly
-     * <code>null</code>)</li>
-     * <li><code>PRIVILEGE</code> - String - Access right - one of SELECT,
-     * INSERT, UPDATE, REFERENCES,...</li>
-     * <li><code>IS_GRANTABLE</code> - String - "YES" implies that the
-     * receiver can grant access to others, "NO" if the receiver cannot grant
-     * access to others, <code>null</code> if unknown.</li>
+     * <li>{@code TABLE_CAT} - String - the catalog name (possibly {@code null})</li>
+     * <li>{@code TABLE_SCHEM} - String - the schema name (possibly {@code null})</li>
+     * <li>{@code TABLE_NAME} - String - the table name</li>
+     * <li>{@code COLUMN_NAME} - String - the Column name</li>
+     * <li>{@code GRANTOR} - String - the grantor of access (possibly {@code
+     * null})</li>
+     * <li>{@code PRIVILEGE} - String - Access right - one of SELECT, INSERT,
+     * UPDATE, REFERENCES,...</li>
+     * <li>{@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.</li>
      * </ol>
-     * 
+     *
      * @param catalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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</code> 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.
+     *            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 ResultSet containing the access rights, one row for each
-     *         privilege description
+     * @return a {@code ResultSet} containing the access rights, one row for
+     *         each privilege description.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public ResultSet getColumnPrivileges(String catalog, String schema,
             String table, String columnNamePattern) throws SQLException;
 
     /**
-     * Answers a description of table columns available in a specified catalog.
-     * Only descriptions meeting the specified Catalog, Schema, Table and Column
+     * Returns a description of table columns available in a specified catalog.
+     * Only descriptions meeting the specified catalog, schema, table, and column
      * names are returned.
      * <p>
-     * The descriptions are returned as a ResultSet conforming to the following
-     * data layout, with one row per table column:
+     * The descriptions are returned as a {@code ResultSet} conforming to the
+     * following data layout, with one row per table column:
      * <ol>
-     * <li><code>TABLE_CAT</code> - String - Catalog name (possibly
-     * <code>null</code>)</li>
-     * <li><code>TABLE_SCHEM</code> - String - Schema name (possibly
-     * <code>null</code>) </li>
-     * <li><code>TABLE_NAME</code> - String - The Table name </li>
-     * <li><code>COLUMN_NAME</code> - String - The Column name</li>
-     * <li><code>DATA_TYPE</code> - int - The SQL type as specified in
-     * <code>java.sql.Types</code></li>
-     * <li><code>TYPE_NAME</code> - String - Name for the data type, depends
-     * on database, UDT names are fully qualified</li>
-     * <li><code>COLUMN_SIZE</code> - int - Column size - the precision for
-     * numeric types, max characters for char and date types</li>
-     * <li><code>BUFFER_LENGTH</code> - int - Not used </li>
-     * <li><code>DECIMAL_DIGITS</code> - int - maximum number of fractional
-     * digits </li>
-     * <li><code>NUM_PREC_RADIX</code> - int - the Radix </li>
-     * <li><code>NULLABLE</code> - int - does the column allow
-     * <code>null</code>s:
+     * <li>{@code TABLE_CAT} - String - the catalog name (possibly {@code null})</li>
+     * <li>{@code TABLE_SCHEM} - String - the schema name (possibly {@code null})</li>
+     * <li>{@code TABLE_NAME} - String - the table name</li>
+     * <li>{@code COLUMN_NAME} - String - the column name</li>
+     * <li>{@code DATA_TYPE} - int - the SQL type as specified in {@code
+     * java.sql.Types}</li>
+     * <li>{@code TYPE_NAME} - String - the name of the data type, (database-dependent, 
+     * UDT names are fully qualified)</li>
+     * <li>{@code COLUMN_SIZE} - int - the column size (the precision for numeric
+     * types, max characters for {@code char} and {@code date} types)</li>
+     * <li>{@code BUFFER_LENGTH} - int - Not used</li>
+     * <li>{@code DECIMAL_DIGITS} - int - maximum number of fractional digits</li>
+     * <li>{@code NUM_PREC_RADIX} - int - the radix for numerical types</li>
+     * <li>{@code NULLABLE} - int - whether the column allows {@code null}s:
      * <ul>
-     * <li>DatabaseMetaData.columnNoNulls = may not allow <code>NULL</code>s</li>
-     * <li>DatabaseMetaData.columnNullable = does allow <code>NULL</code>s</li>
-     * <li>DatabaseMetaData.columnNullableUnknown = unknown <code>NULL</code>
-     * status</li>
+     * <li>DatabaseMetaData.columnNoNulls = may not allow {@code NULL}s</li>
+     * <li>DatabaseMetaData.columnNullable = does allow {@code NULL}s</li>
+     * <li>DatabaseMetaData.columnNullableUnknown = unknown {@code NULL} status</li>
      * </ul>
      * </li>
-     * <li><code>REMARKS</code> - String - A description of the column
-     * (possibly <code>null</code>) </li>
-     * <li><code>COLUMN_DEF</code> - String - Default value for the column
-     * (possibly <code>null</code>)</li>
-     * <li><code>SQL_DATA_TYPE</code> - int - not used </li>
-     * <li><code>SQL_DATETIME_SUB</code> - int - not used </li>
-     * <li><code>CHAR_OCTET_LENGTH</code> - int - maximum number of bytes in
-     * the char type columns </li>
-     * <li><code>ORDINAL_POSITION</code> - int - Column index in the table (1
-     * based) </li>
-     * <li><code>IS_NULLABLE</code> - String - "NO" = column does not allow
-     * NULLs, "YES" = column allows NULLs "" = <code>NULL</code> status
+     * <li>{@code REMARKS} - String - A description of the column (possibly
+     * {@code null})</li>
+     * <li>{@code COLUMN_DEF} - String - Default value for the column (possibly
+     * {@code null})</li>
+     * <li>{@code SQL_DATA_TYPE} - int - not used</li>
+     * <li>{@code SQL_DATETIME_SUB} - int - not used</li>
+     * <li>{@code CHAR_OCTET_LENGTH} - int - maximum number of bytes in the
+     * {@code char} type columns</li>
+     * <li>{@code ORDINAL_POSITION} - int - the column index in the table (1 based)</li>
+     * <li>{@code IS_NULLABLE} - String - {@code "NO"} = column does not allow
+     * NULLs, {@code "YES"} = column allows NULLs, "" = {@code NULL} status
      * unknown</li>
-     * <li><code>SCOPE</code>_CATALOG - String - Catalog for table,
-     * <code>SCOPE</code> of Reference attribute. NULL if
-     * <code>DATA_TYPE</code> is not REF.</li>
-     * <li><code>SCOPE_SCHEMA</code> - String - Schema for table, scope of
-     * Reference attribute. <code>NULL</code> if <code>DATA_TYPE</code> is
-     * not REF.</li>
-     * <li><code>SCOPE_TABLE</code> - String - Table name for scope of
-     * Reference attribute. <code>NULL</code> if <code>DATA_TYPE</code> is
-     * not REF.</li>
-     * <li><code>SOURCE_DATA_TYPE</code> - String - The source type for user
-     * generated REF type or for a Distinct type. (<code>NULL</code> if
-     * <code>DATA_TYPE</code> is not DISTINCT or user generated REF)</li>
+     * <li>{@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.</li>
+     * <li>{@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.</li>
+     * <li>{@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.</li>
+     * <li>{@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)</li>
      * </ol>
-     * 
+     *
      * @param catalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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</code> 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.
+     *            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 ResultSet with rows in the form defined
-     *         above
+     * @return the descriptions as a {@code ResultSet} with rows in the form
+     *         defined above.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public ResultSet getColumns(String catalog, String schemaPattern,
             String tableNamePattern, String columnNamePattern)
             throws SQLException;
 
     /**
-     * Answers the database connection that created this metadata.
+     * Returns the database connection that created this metadata.
      * 
-     * @return the connection
+     * @return the connection to the database.
      * @throws SQLException
-     *             if there is a database error
+     *             if there is a database error.
      */
     public Connection getConnection() throws SQLException;
 
     /**
-     * Answers a list of foreign key columns in a given foreign key table that
+     * 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.
      * <p>
-     * The descriptions are returned as a ResultSet with one row for each
-     * Foreign key, with the following layout:
+     * The descriptions are returned as a {@code ResultSet} with one row for
+     * each foreign key, with the following layout:
      * <ol>
-     * <li><code>PKTABLE_CAT</code> - String - from the primary key table :
-     * Catalog (possibly <code>null</code>)</li>
-     * <li><code>PKTABLE_SCHEM</code> - String - from the primary key table :
-     * Schema (possibly <code>null</code>) </li>
-     * <li><code>PKTABLE_NAME</code> - String - primary key table : name
-     * </li>
-     * <li><code>PKCOLUMN_NAME</code> - String - primary key column : name</li>
-     * <li><code>FKTABLE_CAT</code> - String - from the foreign key table :
-     * the catalog name being exported (possibly <code>null</code>)</li>
-     * <li><code>FKTABLE_SCHEM</code> - String - foreign key table : Schema
-     * name being exported (possibly <code>null</code>) </li>
-     * <li><code>FKTABLE_NAME</code> - String - foreign key table : the name
-     * being exported</li>
-     * <li><code>FKCOLUMN_NAME</code> - String - foreign key column : the
-     * name being exported</li>
-     * <li><code>KEY_SEQ</code> - short - sequence number (in the foreign
-     * key)</li>
-     * <li><code>UPDATE_RULE</code> - short - how to treat foreign key when
-     * primary key is updated:
+     * <li>{@code PKTABLE_CAT} - String - from the primary key table : Catalog
+     * (possibly {@code null})</li>
+     * <li>{@code PKTABLE_SCHEM} - String - from the primary key table : Schema
+     * (possibly {@code null})</li>
+     * <li>{@code PKTABLE_NAME} - String - from the primary key table : name</li>
+     * <li>{@code PKCOLUMN_NAME} - String - from the primary key column : name</li>
+     * <li>{@code FKTABLE_CAT} - String - from the foreign key table : the
+     * catalog name being exported (possibly {@code null})</li>
+     * <li>{@code FKTABLE_SCHEM} - String - from the foreign key table : the schema name
+     * being exported (possibly {@code null})</li>
+     * <li>{@code FKTABLE_NAME} - String - from the foreign key table : the name being
+     * exported</li>
+     * <li>{@code FKCOLUMN_NAME} - String - from the foreign key column : the name being
+     * exported</li>
+     * <li>{@code KEY_SEQ} - short - the sequence number (in the foreign key)</li>
+     * <li>{@code UPDATE_RULE} - short - a value giving the rule for how to treat the corresponding foreign key when a primary
+     * key is updated:
      * <ul>
-     * <li>DatabaseMetaData.importedKeyNoAction - don't allow update of primary
-     * key if imported</li>
-     * <li>DatabaseMetaData.importedKeyCascade - change imported key to match
-     * the primary key update</li>
-     * <li>DatabaseMetaData.importedKeySetNull - set the imported key to
-     * <code>null</code></li>
-     * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to
-     * default values</li>
-     * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li>
+     * <li>{@code DatabaseMetaData.importedKeyNoAction} - don't allow the
+     * primary key to be updated if it is imported as a foreign key</li>
+     * <li>{@code DatabaseMetaData.importedKeyCascade} - change the imported key to
+     * match the updated primary key</li>
+     * <li>{@code DatabaseMetaData.importedKeySetNull} - set the imported key to
+     * {@code null}</li>
+     * <li>{@code DatabaseMetaData.importedKeySetDefault} - set the imported key
+     * to its default value</li>
+     * <li>{@code DatabaseMetaData.importedKeyRestrict} - same as {@code
+     * importedKeyNoAction}</li>
      * </ul>
      * </li>
-     * <li><code>DELETE_RULE</code> - short - how to treat foreign key when
-     * primary key is deleted:
+     * <li>{@code DELETE_RULE} - short - a value giving the rule for how to treat the foreign key when the corresponding primary
+     * key is deleted:
      * <ul>
-     * <li>DatabaseMetaData.importedKeyNoAction - don't allow delete of primary
-     * key if imported</li>
-     * <li>DatabaseMetaData.importedKeyCascade - delete those rows that import
-     * a deleted key</li>
-     * <li>DatabaseMetaData.importedKeySetNull - set the imported key to
-     * <code>null</code></li>
-     * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to
-     * default values</li>
-     * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li>
+     * <li>{@code DatabaseMetaData.importedKeyNoAction} - don't allow the
+     * primary key to be deleted if it is imported as a foreign key</li>
+     * <li>{@code DatabaseMetaData.importedKeyCascade} - delete those rows that
+     * import a deleted key</li>
+     * <li>{@code DatabaseMetaData.importedKeySetNull} - set the imported key to
+     * {@code null}</li>
+     * <li>{@code DatabaseMetaData.importedKeySetDefault} - set the imported key
+     * to its default value</li>
+     * <li>{@code DatabaseMetaData.importedKeyRestrict} - same as
+     * importedKeyNoAction</li>
      * </ul>
      * </li>
-     * <li>FK_NAME - String - foreign key name (possibly <code>null</code>)</li>
-     * <li>PK_NAME - String - primary key name (possibly <code>null</code>)</li>
-     * <li>DEFERRABILITY - short - can foreign key constraints be deferred
-     * until commit (see SQL92 specification for definitions)?:
+     * <li>{@code FK_NAME} - String - the foreign key name (possibly {@code null})</li>
+     * <li>{@code PK_NAME} - String - the primary key name (possibly {@code null})</li>
+     * <li>{@code DEFERRABILITY} - short - whether foreign key constraints can be
+     * deferred until commit (see the SQL92 specification for definitions):
      * <ul>
-     * <li>DatabaseMetaData.importedKeyInitiallyDeferred</li>
-     * <li>DatabaseMetaData.importedKeyInitiallyImmediate</li>
-     * <li>DatabaseMetaData.importedKeyNotDeferrable</li>
+     * <li>{@code DatabaseMetaData.importedKeyInitiallyDeferred}</li>
+     * <li>{@code DatabaseMetaData.importedKeyInitiallyImmediate}</li>
+     * <li>{@code DatabaseMetaData.importedKeyNotDeferrable}</li>
      * </ul>
      * </li>
      * </ol>
-     * 
+     *
      * @param primaryCatalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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. <code>null</code> 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.
+     *            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
+     *            name of the table in the database.
      * @param foreignCatalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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. <code>null</code> 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.
+     *            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 ResultSet containing rows with the descriptions of the foreign
-     *         keys laid out according to the format defined above.
+     *            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
+     *             if there is a database error.
      */
     public ResultSet getCrossReference(String primaryCatalog,
             String primarySchema, String primaryTable, String foreignCatalog,
             String foreignSchema, String foreignTable) throws SQLException;
 
     /**
-     * Answers the major version number of the database software.
+     * Returns the major version number of the database software.
      * 
-     * @return the Major version number of the database software.
+     * @return the major version number of the database software.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public int getDatabaseMajorVersion() throws SQLException;
 
     /**
-     * Answers the minor version number of the database software.
+     * Returns the minor version number of the database software.
      * 
-     * @return the Minor version number of the database software.
+     * @return the minor version number of the database software.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public int getDatabaseMinorVersion() throws SQLException;
 
     /**
-     * Answers the name of the database software.
+     * Returns the name of the database software.
      * 
-     * @return a String with the name of the database software.
+     * @return a {@code String} with the name of the database software.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public String getDatabaseProductName() throws SQLException;
 
     /**
-     * Answers the version number of this database software.
+     * Returns the version number of this database software.
      * 
-     * @return a String with the version number of the database software.
+     * @return a {@code String} with the version number of the database
+     *         software.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public String getDatabaseProductVersion() throws SQLException;
 
     /**
-     * Answers the default transaction isolation level for this database.
+     * Returns the default transaction isolation level for this database.
      * 
-     * @return the default transaction isolation level. One of
-     *         <code>TRANSACTION_NONE</code>,
-     *         <code>TRANSACTION_READ_COMMITTED</code>,
-     *         <code>TRANSACTION_READ_UNCOMMITTED</code>,
-     *         <code>TRANSACTION_REPEATABLE_READ</code> or
-     *         <code>TRANSACTION_SERIALIZABLE</code>.
+     * @return the default transaction isolation level. One of the following values:
+     *         <ul>
+     *         <li>{@code TRANSACTION_NONE}</li>
+     *         <li>{@code TRANSACTION_READ_COMMITTED}</li>
+     *         <li>{@code TRANSACTION_READ_UNCOMMITTED}</li>
+     *         <li>{@code TRANSACTION_REPEATABLE_READ}</li>
+     *         <li>{@code TRANSACTION_SERIALIZABLE}</li>
+     *         </ul>
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public int getDefaultTransactionIsolation() throws SQLException;
 
     /**
-     * Answers the JDBC driver's major version number.
+     * Returns the JDBC driver's major version number.
      * 
-     * @return the driver's major version number
+     * @return the driver's major version number.
      */
     public int getDriverMajorVersion();
 
     /**
-     * Answers the JDBC driver's minor version number.
+     * Returns the JDBC driver's minor version number.
      * 
-     * @return the driver's minor version number
+     * @return the driver's minor version number.
      */
     public int getDriverMinorVersion();
 
     /**
-     * Answers the name of this JDBC driver.
+     * Returns the name of this JDBC driver.
      * 
-     * @return a String containing the name of the JDBC driver
+     * @return a {@code String} containing the name of the JDBC driver
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public String getDriverName() throws SQLException;
 
     /**
-     * Answers the version number of this JDBC driver.
+     * Returns the version number of this JDBC driver.
      * 
-     * @return a String containing the complete version number of the JDBC
-     *         driver
+     * @return a {@code String} containing the complete version number of the
+     *         JDBC driver.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public String getDriverVersion() throws SQLException;
 
     /**
-     * Answers a list of the foreign key columns that reference the primary key
+     * 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).
      * <p>
-     * The list is returned as a ResultSet with a row for each of the foreign
-     * key columns, ordered by <code>FKTABLE_CAT</code>,
-     * <code>FKTABLE_SCHEM</code>, <code>FKTABLE_NAME</code>, and
-     * <code>KEY_SEQ</code>, with the format for each row being:
+     * 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:
      * <ol>
-     * <li><code>PKTABLE_CAT</code> - String - primary key table : Catalog
-     * (possibly <code>null</code>)</li>
-     * <li><code>PKTABLE_SCHEM</code> - String - primary key table : Schema
-     * (possibly <code>null</code>) </li>
-     * <li><code>PKTABLE_NAME</code> - String - primary key table : name
-     * </li>
-     * <li><code>PKCOLUMN_NAME</code> - String - primary key column : name</li>
-     * <li><code>FKTABLE_CAT</code> - String - foreign key table : Catalog
-     * name being exported (possibly <code>null</code>)</li>
-     * <li><code>FKTABLE_SCHEM</code> - String - foreign key table : Schema
-     * name being exported (possibly <code>null</code>) </li>
-     * <li><code>FKTABLE_NAME</code> - String - foreign key table : name
-     * being exported</li>
-     * <li><code>FKCOLUMN_NAME</code> - String - foreign key column : name
-     * being exported</li>
-     * <li>KEY_SEQ - short - sequence number in the foreign key</li>
-     * <li>UPDATE_RULE - short - how to treat foreign key when primary key is
-     * updated:
+     * <li>{@code PKTABLE_CAT} - String - from the primary key table : the catalog (possibly
+     * {@code null})</li>
+     * <li>{@code PKTABLE_SCHEM} - String - from the primary key table : the schema (possibly
+     * {@code null})</li>
+     * <li>{@code PKTABLE_NAME} - String - from the primary key table : the name</li>
+     * <li>{@code PKCOLUMN_NAME} - String - from the primary key column : the name</li>
+     * <li>{@code FKTABLE_CAT} - String - from the foreign key table : the catalog name being
+     * exported (possibly {@code null})</li>
+     * <li>{@code FKTABLE_SCHEM} - String - from the foreign key table : the schema name
+     * being exported (possibly {@code null})</li>
+     * <li>{@code FKTABLE_NAME} - String - from the foreign key table : the name being
+     * exported</li>
+     * <li>{@code FKCOLUMN_NAME} - String - from the foreign key column : the name being
+     * exported</li>
+     * <li>{@code KEY_SEQ} - short - the sequence number (in the foreign key)</li>
+     * <li>{@code UPDATE_RULE} - short - a value giving the rule for how to treat the foreign key when the corresponding primary
+     * key is updated:
      * <ul>
-     * <li>DatabaseMetaData.importedKeyNoAction - don't allow update of primary
-     * key if imported</li>
-     * <li>DatabaseMetaData.importedKeyCascade - change imported key to match
-     * the primary key update</li>
-     * <li>DatabaseMetaData.importedKeySetNull - set the imported key to
-     * <code>null</code></li>
-     * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to
-     * default values</li>
-     * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li>
+     * <li>{@code DatabaseMetaData.importedKeyNoAction} - don't allow the 
+     * primary key to be updated if it is imported as a foreign key</li>
+     * <li>{@code DatabaseMetaData.importedKeyCascade} - change the imported key to
+     * match the primary key update</li>
+     * <li>{@code DatabaseMetaData.importedKeySetNull} - set the imported key to
+     * {@code null}</li>
+     * <li>{@code DatabaseMetaData.importedKeySetDefault} - set the imported key
+     * to its default value</li>
+     * <li>{@code DatabaseMetaData.importedKeyRestrict} - same as
+     * importedKeyNoAction</li>
      * </ul>
      * </li>
-     * <li>DELETE_RULE - short - how to treat foreign key when primary key is
-     * deleted:
+     * <li>{@code DELETE_RULE} - short - how to treat the foreign key when the corresponding primary
+     * key is deleted:
      * <ul>
-     * <li>DatabaseMetaData.importedKeyNoAction - don't allow delete of primary
-     * key if imported</li>
-     * <li>DatabaseMetaData.importedKeyCascade - the deletion should also
-     * delete rows that import a deleted key</li>
-     * <li>DatabaseMetaData.importedKeySetNull - it should set the imported key
-     * to <code>null</code></li>
-     * <li>DatabaseMetaData.importedKeySetDefault - deletion sets the imported
-     * key to default values</li>
-     * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li>
+     * <li>{@code DatabaseMetaData.importedKeyNoAction} - don't allow the
+     * primary key to be deleted if it is imported as a foreign key</li>
+     * <li>{@code DatabaseMetaData.importedKeyCascade} - the deletion should
+     * also delete rows that import a deleted key</li>
+     * <li>{@code DatabaseMetaData.importedKeySetNull} - the deletion sets the
+     * imported key to {@code null}</li>
+     * <li>{@code DatabaseMetaData.importedKeySetDefault} - the deletion sets the
+     * imported key to its default value</li>
+     * <li>{@code DatabaseMetaData.importedKeyRestrict} - same as
+     * importedKeyNoAction</li>
      * </ul>
      * </li>
-     * <li>FK_NAME - String - foreign key name (possibly <code>null</code>)</li>
-     * <li>PK_NAME - String - primary key name (possibly <code>null</code>)</li>
-     * <li>DEFERRABILITY - short - defines whether foreign key constraints can
-     * be deferred until commit (see SQL92 specification for definitions):
+     * <li>{@code FK_NAME} - String - the foreign key name (possibly {@code null})</li>
+     * <li>{@code PK_NAME} - String - the primary key name (possibly {@code null})</li>
+     * <li>{@code DEFERRABILITY} - short - defines whether the foreign key
+     * constraints can be deferred until commit (see the SQL92 specification for
+     * definitions):
      * <ul>
-     * <li>DatabaseMetaData.importedKeyInitiallyDeferred</li>
-     * <li>DatabaseMetaData.importedKeyInitiallyImmediate</li>
-     * <li>DatabaseMetaData.importedKeyNotDeferrable</li>
+     * <li>{@code DatabaseMetaData.importedKeyInitiallyDeferred}</li>
+     * <li>{@code DatabaseMetaData.importedKeyInitiallyImmediate}</li>
+     * <li>{@code DatabaseMetaData.importedKeyNotDeferrable}</li>
      * </ul>
      * </li>
      * </ol>
-     * 
+     *
      * @param catalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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</code> 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.
+     *            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 ResultSet containing a row for each of the foreign key columns,
-     *         as defined above
+     * @return a {@code ResultSet} containing a row for each of the foreign key
+     *         columns, as defined above
      * @throws SQLException
      *             a database error occurred
      */
@@ -961,197 +956,201 @@
             throws SQLException;
 
     /**
-     * Answers a string of characters that may be used in unquoted identifier
-     * names. The characters a-z, A-Z, 0-9 and _ are always permitted.
+     * 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 extra characters
+     * @return a String containing all the additional permitted characters.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public String getExtraNameCharacters() throws SQLException;
 
     /**
-     * Answers the string used to quote SQL identifiers. Returns " " (space) if
+     * 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
+     *             a database error occurred.
      */
     public String getIdentifierQuoteString() throws SQLException;
 
     /**
-     * Answers a list columns in a table that are both primary keys and
+     * 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).
      * <p>
-     * The list returned is a <code>ResultSet</code> with a row entry for each
-     * primary key column, ordered by <code>PKTABLE_CAT</code>,
-     * <code>PKTABLE_SCHEM</code>, <code>PKTABLE_NAME</code>, and
-     * <code>KEY_SEQ</code>, with the following format:
+     * 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:
      * <ol>
-     * <li><code>PKTABLE_CAT</code> - String - primary key Catalog name being
-     * imported (possibly <code>null</code>)</li>
-     * <li><code>PKTABLE_SCHEM</code> - String - primary key Schema name
-     * being imported (possibly <code>null</code>) </li>
-     * <li><code>PKTABLE_NAME</code> - String - primary key Table name being
-     * imported </li>
-     * <li><code>PKCOLUMN_NAME</code> - String - primary key column name
-     * being imported</li>
-     * <li><code>FKTABLE_CAT</code> - String - foreign key table catalog name
-     * (possibly <code>null</code>)</li>
-     * <li><code>FKTABLE_SCHEM</code> - String - foreign key table Schema
-     * name (possibly <code>null</code>) </li>
-     * <li><code>FKTABLE_NAME</code> - String - foreign key table name</li>
-     * <li><code>FKCOLUMN_NAME</code> - String - foreign key column name</li>
-     * <li>KEY_SEQ - short - sequence number in the foreign key</li>
-     * <li>UPDATE_RULE - short - how to treat foreign key when primary key is
-     * updated:
+     * <li>{@code PKTABLE_CAT} - String - primary key catalog name being
+     * imported (possibly {@code null})</li>
+     * <li>{@code PKTABLE_SCHEM} - String - primary key schema name being
+     * imported (possibly {@code null})</li>
+     * <li>{@code PKTABLE_NAME} - String - primary key table name being imported
+     * </li>
+     * <li>{@code PKCOLUMN_NAME} - String - primary key column name being
+     * imported</li>
+     * <li>{@code FKTABLE_CAT} - String - foreign key table catalog name
+     * (possibly {@code null})</li>
+     * <li>{@code FKTABLE_SCHEM} - String - foreign key table schema name
+     * (possibly {@code null})</li>
+     * <li>{@code FKTABLE_NAME} - String - foreign key table name</li>
+     * <li>{@code FKCOLUMN_NAME} - String - foreign key column name</li>
+     * <li>{@code KEY_SEQ} - short - sequence number (in the foreign key)</li>
+     * <li>{@code UPDATE_RULE} - short - how to treat the foreign key when the corresponding primary
+     * key is updated:
      * <ul>
-     * <li>DatabaseMetaData.importedKeyNoAction - don't allow update of primary
-     * key if imported</li>
-     * <li>DatabaseMetaData.importedKeyCascade - change imported key to match
-     * the primary key update</li>
-     * <li>DatabaseMetaData.importedKeySetNull - set the imported key to
-     * <code>null</code></li>
-     * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to
-     * default values</li>
-     * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li>
+     * <li>{@code DatabaseMetaData.importedKeyNoAction} - don't allow any update of
+     * the primary key if it is imported as a foreign key</li>
+     * <li>{@code DatabaseMetaData.importedKeyCascade} - change imported key to
+     * match the primary key update</li>
+     * <li>{@code DatabaseMetaData.importedKeySetNull} - set the imported key to
+     * {@code null}</li>
+     * <li>{@code DatabaseMetaData.importedKeySetDefault} - set the imported key
+     * to its default value</li>
+     * <li>{@code DatabaseMetaData.importedKeyRestrict} - same as
+     * importedKeyNoAction</li>
      * </ul>
      * </li>
-     * <li>DELETE_RULE - short - how to treat foreign key when primary key is
-     * deleted:
+     * <li>{@code DELETE_RULE} - short - how to treat the foreign key when the corresponding primary
+     * key is deleted:
      * <ul>
-     * <li>DatabaseMetaData.importedKeyNoAction - don't allow delete of primary
-     * key if imported</li>
-     * <li>DatabaseMetaData.importedKeyCascade - delete those rows that import
-     * a deleted key</li>
-     * <li>DatabaseMetaData.importedKeySetNull - set the imported key to
-     * <code>null</code></li>
-     * <li>DatabaseMetaData.importedKeySetDefault - set the imported key to
-     * default values</li>
-     * <li>DatabaseMetaData.importedKeyRestrict - same as importedKeyNoAction</li>
+     * <li>{@code DatabaseMetaData.importedKeyNoAction} - don't allow the primary key to be deleted
+     * if it is imported as a foreign key</li>
+     * <li>{@code DatabaseMetaData.importedKeyCascade} - delete those rows that
+     * import a deleted key</li>
+     * <li>{@code DatabaseMetaData.importedKeySetNull} - set the imported key to
+     * {@code null}</li>
+     * <li>{@code DatabaseMetaData.importedKeySetDefault} - set the imported key
+     * to its default value</li>
+     * <li>{@code DatabaseMetaData.importedKeyRestrict} - same as {@code
+     * importedKeyNoAction}</li>
      * </ul>
      * </li>
-     * <li>FK_NAME - String - foreign key name (possibly <code>null</code>)</li>
-     * <li>PK_NAME - String - primary key name (possibly <code>null</code>)</li>
-     * <li>DEFERRABILITY - short - defines whether foreign key constraints can
-     * be deferred until commit (see SQL92 specification for definitions):
+     * <li>{@code FK_NAME} - String - foreign key name (possibly {@code null})</li>
+     * <li>{@code PK_NAME} - String - primary key name (possibly {@code null})</li>
+     * <li>{@code DEFERRABILITY} - short - defines whether foreign key
+     * constraints can be deferred until commit (see SQL92 specification for
+     * definitions):
      * <ul>
-     * <li>DatabaseMetaData.importedKeyInitiallyDeferred</li>
-     * <li>DatabaseMetaData.importedKeyInitiallyImmediate</li>
-     * <li>DatabaseMetaData.importedKeyNotDeferrable</li>
+     * <li>{@code DatabaseMetaData.importedKeyInitiallyDeferred}</li>
+     * <li>{@code DatabaseMetaData.importedKeyInitiallyImmediate}</li>
+     * <li>{@code DatabaseMetaData.importedKeyNotDeferrable}</li>
      * </ul>
      * </li>
      * </ol>
-     * 
+     *
      * @param catalog
-     *            a Catalog Name. <code>null</code> 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.
+     *            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</code> 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.
+     *            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 ResultSet containing the list of primary key columns as rows in
-     *         the format defined above.
+     *            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
+     *             a database error occurred.
      */
     public ResultSet getImportedKeys(String catalog, String schema, String table)
             throws SQLException;
 
     /**
-     * Answers a list of indices and statistics for a specified table.
+     * Returns a list of indices and statistics for a specified table.
      * <p>
-     * The list is returned as a ResultSet, with one row for each index or
-     * statistic. The list is ordered by NON_UNIQUE, TYPE, INDEX_NAME, and
-     * ORDINAL_POSITION. Each row has the following format:
+     * 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:
      * <ol>
-     * <li><code>TABLE_CAT</code> - String - table catalog name (possibly
-     * <code>null</code>)</li>
-     * <li><code>TABLE_SCHEM</code> - String - Table Schema name (possibly
-     * <code>null</code>) </li>
-     * <li><code>TABLE_NAME</code> - String - The Table name </li>
-     * <li><code>NON_UNIQUE</code> - boolean - <code>true</code> when index
-     * values can be non-unique. Must be <code>false</code> when TYPE is
-     * tableIndexStatistic</li>
-     * <li><code>INDEX_QUALIFIER</code> - String : index catalog name.
-     * <code>null</code> when TYPE is 'tableIndexStatistic'</li>
-     * <li><code>INDEX_NAME</code> - String : index name. <code>null</code>
-     * when TYPE is 'tableIndexStatistic'</li>
-     * <li>TYPE - short - the index type. One of:
+     * <li>{@code TABLE_CAT} - String - table catalog name (possibly {@code
+     * null})</li>
+     * <li>{@code TABLE_SCHEM} - String - table schema name (possibly {@code
+     * null})</li>
+     * <li>{@code TABLE_NAME} - String - The table name</li>
+     * <li>{@code NON_UNIQUE} - boolean - {@code true} when index values can be
+     * non-unique. Must be {@code false} when the TYPE is tableIndexStatistic</li>
+     * <li>{@code INDEX_QUALIFIER} - String : index catalog name. {@code null}
+     * when the TYPE is 'tableIndexStatistic'</li>
+     * <li>{@code INDEX_NAME} - String : index name. {@code null} when TYPE is
+     * 'tableIndexStatistic'</li>
+     * <li>{@code TYPE} - short - the index type. One of:
      * <ul>
-     * <li>DatabaseMetaData.tableIndexStatistic - table statistics returned
-     * with Index descriptions</li>
-     * <li>DatabaseMetaData.tableIndexClustered - a clustered Index</li>
-     * <li>DatabaseMetaData.tableIndexHashed - a hashed Index</li>
-     * <li>DatabaseMetaData.tableIndexOther - other style of Index</li>
+     * <li>{@code DatabaseMetaData.tableIndexStatistic} - table statistics
+     * returned with Index descriptions</li>
+     * <li>{@code DatabaseMetaData.tableIndexClustered} - a clustered Index</li>
+     * <li>{@code DatabaseMetaData.tableIndexHashed} - a hashed Index</li>
+     * <li>{@code DatabaseMetaData.tableIndexOther} - other style of Index</li>
      * </ul>
      * </li>
-     * <li>ORDINAL_POSITION - short - column sequence within Index. 0 when TYPE
-     * is tableIndexStatistic </li>
-     * <li><code>COLUMN_NAME</code> - String - the column name.
-     * <code>null</code> when TYPE is tableIndexStatistic</li>
-     * <li>ASC_OR_DESC - String - column sort sequence. <code>null</code> if
+     * <li>{@code ORDINAL_POSITION} - short - column sequence within Index. 0
+     * when TYPE is tableIndexStatistic</li>
+     * <li>{@code COLUMN_NAME} - String - the column name. {@code null} when
+     * TYPE is tableIndexStatistic</li>
+     * <li>{@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. </li>
-     * <li>CARDINALITY - int - Number of unique values in the Index. If TYPE is
-     * tableIndexStatistic, this is number of rows in the table.</li>
-     * <li>PAGES - int - Number of pages for current Index. If TYPE is
+     * means sort ascending and "D" means sort descending.</li>
+     * <li>{@code CARDINALITY} - int - Number of unique values in the Index. If
+     * TYPE is tableIndexStatistic, this is number of rows in the table.</li>
+     * <li>{@code PAGES} - int - Number of pages for current Index. If TYPE is
      * tableIndexStatistic, this is number of pages used for the table.</li>
-     * <li>FILTER_CONDITION - String - Filter condition. (possibly null) </li>
+     * <li>{@code FILTER_CONDITION} - String - Filter condition. (possibly null)
+     * </li>
      * </ol>
-     * 
+     *
      * @param catalog
-     *            a Catalog Name. 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.
+     *            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. 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.
+     *            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
+     *            database.
      * @param unique
-     *            <code>true</code> means only return indices for unique
-     *            values, <code>false</code> implies that they can be returned
-     *            even if not 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</code> implies that the list can contain
-     *            approximate or "out of data" values, <code>false</code>
-     *            implies that all values must be precisely accurate
-     * @return a ResultSet containing the list of indices and statistics for the
-     *         table, in the format defined above.
+     *            {@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
+     *             a database error occurred.
      */
     public ResultSet getIndexInfo(String catalog, String schema, String table,
             boolean unique, boolean approximate) throws SQLException;
 
     /**
-     * Answers this driver's major JDBC version number.
+     * Returns this driver's major JDBC version number.
      * 
-     * @return the major JDBC version number
+     * @return the major JDBC version number.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public int getJDBCMajorVersion() throws SQLException;
 
     /**
-     * Answers the minor JDBC version number for this driver.
+     * Returns the minor JDBC version number for this driver.
      * 
-     * @return the Minor JDBC Version Number
+     * @return the Minor JDBC Version Number.
      * @throws SQLException
-     *             a database error occurred
+     *             a database error occurred.
      */
     public int getJDBCMinorVersion() throws SQLException;
 
@@ -1162,166 +1161,171 @@
      * @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
+     *             a database error occurred.
      */
     public int getMaxBinaryLiteralLength() throws SQLException;
 
     /**
-     * Answers the maximum size of a Catalog name in this database.
+     * Returns the maximum size of a catalog name in this database.
      * 
-     * @return the maximum size in characters for a Catalog name. If the limit
+     * @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
+     *             a database error occurred.
      */
     public int getMaxCatalogNameLength() throws SQLException;
 
     /**
-     * Answers the maximum size for a character literal in this database.
+     * 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
+     *             a database error occurred.
      */
     public int getMaxCharLiteralLength() throws SQLException;
 
     /**
-     * Answers the maximum size for a Column name for this database.
+     * 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
+     *             a database error occurred.
      */
     public int getMaxColumnNameLength() throws SQLException;
 
     /**
-     * Get the maximum number of columns in a GROUP BY clause for this database.
+     * Get the maximum number of columns in a {@code GROUP BY} clause for this
+     * database.
      * 
-     * @return the maximum number of columns in a GROUP BY clause. If the limit
-     *         is unknown, or the value is unlimited, then the result is zero.
+     * @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
+     *             a database error occurred.
      */
     public int getMaxColumnsInGroupBy() throws SQLException;
 
     /**
-     * Answers the maximum number of columns in an Index for this database.
+     * 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
+     *             a database error occurred.
      */
     public int getMaxColumnsInIndex() throws SQLException;
 
     /**
-     * Answers the maximum number of columns in an ORDER BY clause for this
-     * database.
+     * Returns the maximum number of columns in an {@code ORDER BY} clause for
+     * this database.
      * 
-     * @return the maximum number of columns in an ORDER BY clause. If the limit
-     *         is unknown, or the value is unlimited, then the result is zero.
+     * @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
+     *             a database error occurred.
      */
     public int getMaxColumnsInOrderBy() throws SQLException;
 
     /**
-     * Answers the maximum number of columns in a SELECT list for this database.
+     * Returns the maximum number of columns in a {@code SELECT} list for this
+     * database.
      * 
-     * @return the maximum number of columns in a SELECT list. If the limit is
-     *         unknown, or the value is unlimited, then the result is zero.
+     * @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.

[... 2708 lines stripped ...]


Mime
View raw message