Polish simple JDBC support classes

Author: sbrannen

spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/GenericTableMetaDataProvider.java

@@ -158,7 +158,7 @@ public void initializeWithMetaData(DatabaseMetaData databaseMetaData) throws SQL
 		}
 		catch (SQLException ex) {
 			if (logger.isWarnEnabled()) {
-				logger.warn("Error retrieving 'DatabaseMetaData.getGeneratedKeys': " + ex.getMessage());
+				logger.warn("Error retrieving 'DatabaseMetaData.supportsGetGeneratedKeys': " + ex.getMessage());
 			}
 		}
 		try {
@@ -226,51 +226,33 @@ public void initializeWithTableColumnMetaData(DatabaseMetaData databaseMetaData,
 	@Override
 	@Nullable
 	public String tableNameToUse(@Nullable String tableName) {
-		if (tableName == null) {
-			return null;
-		}
-		else if (isStoresUpperCaseIdentifiers()) {
-			return tableName.toUpperCase();
-		}
-		else if (isStoresLowerCaseIdentifiers()) {
-			return tableName.toLowerCase();
-		}
-		else {
-			return tableName;
-		}
+		return identifierNameToUse(tableName);
 	}
 
 	@Override
 	@Nullable
 	public String catalogNameToUse(@Nullable String catalogName) {
-		if (catalogName == null) {
-			return null;
-		}
-		else if (isStoresUpperCaseIdentifiers()) {
-			return catalogName.toUpperCase();
-		}
-		else if (isStoresLowerCaseIdentifiers()) {
-			return catalogName.toLowerCase();
-		}
-		else {
-			return catalogName;
-		}
+		return identifierNameToUse(catalogName);
 	}
 
 	@Override
 	@Nullable
 	public String schemaNameToUse(@Nullable String schemaName) {
-		if (schemaName == null) {
+		return identifierNameToUse(schemaName);
+	}
+
+	private String identifierNameToUse(String identifierName) {
+		if (identifierName == null) {
 			return null;
 		}
 		else if (isStoresUpperCaseIdentifiers()) {
-			return schemaName.toUpperCase();
+			return identifierName.toUpperCase();
 		}
 		else if (isStoresLowerCaseIdentifiers()) {
-			return schemaName.toLowerCase();
+			return identifierName.toLowerCase();
 		}
 		else {
-			return schemaName;
+			return identifierName;
 		}
 	}
 
@@ -290,15 +272,15 @@ public String metaDataSchemaNameToUse(@Nullable String schemaName) {
 	}
 
 	/**
-	 * Provide access to default schema for subclasses.
+	 * Provide access to the default schema for subclasses.
 	 */
 	@Nullable
 	protected String getDefaultSchema() {
 		return this.userName;
 	}
 
 	/**
-	 * Provide access to version info for subclasses.
+	 * Provide access to the version info for subclasses.
 	 */
 	@Nullable
 	protected String getDatabaseVersion() {

spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/TableMetaDataContext.java

@@ -349,35 +349,33 @@ public int[] createInsertTypes() {
 
 
 	/**
-	 * Does this database support the JDBC 3.0 feature of retrieving generated keys:
-	 * {@link java.sql.DatabaseMetaData#supportsGetGeneratedKeys()}?
+	 * Does this database support the JDBC 3.0 feature of retrieving generated keys?
+	 * @see java.sql.DatabaseMetaData#supportsGetGeneratedKeys()
 	 */
 	public boolean isGetGeneratedKeysSupported() {
 		return obtainMetaDataProvider().isGetGeneratedKeysSupported();
 	}
 
 	/**
-	 * Does this database support simple query to retrieve generated keys
-	 * when the JDBC 3.0 feature is not supported:
-	 * {@link java.sql.DatabaseMetaData#supportsGetGeneratedKeys()}?
+	 * Does this database support a simple query to retrieve the generated key when
+	 * the JDBC 3.0 feature of retrieving generated keys is not supported?
+	 * @see #isGetGeneratedKeysSupported()
 	 */
 	public boolean isGetGeneratedKeysSimulated() {
 		return obtainMetaDataProvider().isGetGeneratedKeysSimulated();
 	}
 
 	/**
-	 * Does this database support a simple query to retrieve generated keys
-	 * when the JDBC 3.0 feature is not supported:
-	 * {@link java.sql.DatabaseMetaData#supportsGetGeneratedKeys()}?
+	 * Get the simple query to retrieve a generated key.
 	 */
 	@Nullable
 	public String getSimpleQueryForGetGeneratedKey(String tableName, String keyColumnName) {
 		return obtainMetaDataProvider().getSimpleQueryForGetGeneratedKey(tableName, keyColumnName);
 	}
 
 	/**
-	 * Is a column name String array for retrieving generated keys supported:
-	 * {@link java.sql.Connection#createStruct(String, Object[])}?
+	 * Is a column name String array for retrieving generated keys supported?
+	 * @see java.sql.Connection#createStruct(String, Object[])
 	 */
 	public boolean isGeneratedKeysColumnNameArraySupported() {
 		return obtainMetaDataProvider().isGeneratedKeysColumnNameArraySupported();

spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/TableMetaDataProvider.java

@@ -24,9 +24,11 @@
 
 /**
  * Interface specifying the API to be implemented by a class providing table meta-data.
- * This is intended for internal use by the Simple JDBC classes.
+ *
+ * <p>This is intended for internal use by the Simple JDBC classes.
  *
  * @author Thomas Risberg
+ * @author Sam Brannen
  * @since 2.5
  */
 public interface TableMetaDataProvider {
@@ -40,7 +42,8 @@ public interface TableMetaDataProvider {
 
 	/**
 	 * Initialize using provided database meta-data, table and column information.
-	 * This initialization can be turned off by specifying that column meta-data should not be used.
+	 * <p>This initialization can be turned off by specifying that column meta-data
+	 * should not be used.
 	 * @param databaseMetaData used to retrieve database specific information
 	 * @param catalogName name of catalog to use (or {@code null} if none)
 	 * @param schemaName name of schema name to use (or {@code null} if none)
@@ -52,37 +55,41 @@ void initializeWithTableColumnMetaData(DatabaseMetaData databaseMetaData, @Nulla
 
 	/**
 	 * Get the table name formatted based on meta-data information.
-	 * This could include altering the case.
+	 * <p>This could include altering the case.
 	 */
 	@Nullable
 	String tableNameToUse(@Nullable String tableName);
 
 	/**
 	 * Get the catalog name formatted based on meta-data information.
-	 * This could include altering the case.
+	 * <p>This could include altering the case.
 	 */
 	@Nullable
 	String catalogNameToUse(@Nullable String catalogName);
 
 	/**
 	 * Get the schema name formatted based on meta-data information.
-	 * This could include altering the case.
+	 * <p>This could include altering the case.
 	 */
 	@Nullable
 	String schemaNameToUse(@Nullable String schemaName);
 
 	/**
-	 * Provide any modification of the catalog name passed in to match the meta-data currently used.
-	 * The returned value will be used for meta-data lookups.
-	 * This could include altering the case used or providing a base catalog if none is provided.
+	 * Provide any modification of the catalog name passed in to match the meta-data
+	 * currently used.
+	 * <p>The returned value will be used for meta-data lookups.
+	 * <p>This could include altering the case used or providing a base catalog
+	 * if none is provided.
 	 */
 	@Nullable
 	String metaDataCatalogNameToUse(@Nullable String catalogName) ;
 
 	/**
-	 * Provide any modification of the schema name passed in to match the meta-data currently used.
-	 * The returned value will be used for meta-data lookups.
-	 * This could include altering the case used or providing a base schema if none is provided.
+	 * Provide any modification of the schema name passed in to match the meta-data
+	 * currently used.
+	 * <p>The returned value will be used for meta-data lookups.
+	 * <p>This could include altering the case used or providing a base schema
+	 * if none is provided.
 	 */
 	@Nullable
 	String metaDataSchemaNameToUse(@Nullable String schemaName) ;
@@ -93,8 +100,8 @@ void initializeWithTableColumnMetaData(DatabaseMetaData databaseMetaData, @Nulla
 	boolean isTableColumnMetaDataUsed();
 
 	/**
-	 * Does this database support the JDBC 3.0 feature of retrieving generated keys:
-	 * {@link java.sql.DatabaseMetaData#supportsGetGeneratedKeys()}?
+	 * Does this database support the JDBC 3.0 feature of retrieving generated keys?
+	 * @see java.sql.DatabaseMetaData#supportsGetGeneratedKeys()
 	 */
 	boolean isGetGeneratedKeysSupported();
 
@@ -112,8 +119,9 @@ void initializeWithTableColumnMetaData(DatabaseMetaData databaseMetaData, @Nulla
 	String getSimpleQueryForGetGeneratedKey(String tableName, String keyColumnName);
 
 	/**
-	 * Does this database support a column name String array for retrieving generated keys:
-	 * {@link java.sql.Connection#createStruct(String, Object[])}?
+	 * Does this database support a column name String array for retrieving generated
+	 * keys?
+	 * @see java.sql.Connection#createStruct(String, Object[])
 	 */
 	boolean isGeneratedKeysColumnNameArraySupported();
 

spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/AbstractJdbcInsert.java

@@ -57,6 +57,7 @@
  *
  * @author Thomas Risberg
  * @author Juergen Hoeller
+ * @author Sam Brannen
  * @since 2.5
  */
 public abstract class AbstractJdbcInsert {
@@ -91,15 +92,15 @@ public abstract class AbstractJdbcInsert {
 
 	/**
 	 * Constructor to be used when initializing using a {@link DataSource}.
-	 * @param dataSource the DataSource to be used
+	 * @param dataSource the {@code DataSource} to be used
 	 */
 	protected AbstractJdbcInsert(DataSource dataSource) {
 		this.jdbcTemplate = new JdbcTemplate(dataSource);
 	}
 
 	/**
 	 * Constructor to be used when initializing using a {@link JdbcTemplate}.
-	 * @param jdbcTemplate the JdbcTemplate to use
+	 * @param jdbcTemplate the {@code JdbcTemplate} to use
 	 */
 	protected AbstractJdbcInsert(JdbcTemplate jdbcTemplate) {
 		Assert.notNull(jdbcTemplate, "JdbcTemplate must not be null");
@@ -207,15 +208,15 @@ public String[] getGeneratedKeyNames() {
 
 	/**
 	 * Specify whether the parameter meta-data for the call should be used.
-	 * The default is {@code true}.
+	 * <p>The default is {@code true}.
 	 */
 	public void setAccessTableColumnMetaData(boolean accessTableColumnMetaData) {
 		this.tableMetaDataContext.setAccessTableColumnMetaData(accessTableColumnMetaData);
 	}
 
 	/**
 	 * Specify whether the default for including synonyms should be changed.
-	 * The default is {@code false}.
+	 * <p>The default is {@code false}.
 	 */
 	public void setOverrideIncludeSynonymsDefault(boolean override) {
 		this.tableMetaDataContext.setOverrideIncludeSynonymsDefault(override);

spring-jdbc/src/main/java/org/springframework/jdbc/core/simple/SimpleJdbcInsert.java

@@ -26,33 +26,35 @@
 import org.springframework.jdbc.support.KeyHolder;
 
 /**
- * A SimpleJdbcInsert is a multithreaded, reusable object providing easy (batch) insert
- * capabilities for a table. It provides meta-data processing to simplify the code
- * needed to construct a basic insert statement. All you need to provide is the name
- * of the table and a Map containing the column names and the column values.
+ * A {@code SimpleJdbcInsert} is a multi-threaded, reusable object providing easy
+ * (batch) insert capabilities for a table. It provides meta-data processing to
+ * simplify the code needed to construct a basic insert statement. All you need
+ * to provide is the name of the table and a {@code Map} containing the column
+ * names and the column values.
  *
- * <p>The meta-data processing is based on the DatabaseMetaData provided by the
- * JDBC driver. As long as the JDBC driver can provide the names of the columns
+ * <p>The meta-data processing is based on the {@code DatabaseMetaData} provided
+ * by the JDBC driver. As long as the JDBC driver can provide the names of the columns
  * for a specified table then we can rely on this auto-detection feature. If that
  * is not the case, then the column names must be specified explicitly.
  *
  * <p>The actual (batch) insert is handled using Spring's {@link JdbcTemplate}.
  *
  * <p>Many of the configuration methods return the current instance of the
- * SimpleJdbcInsert to provide the ability to chain multiple ones together
- * in a "fluent" interface style.
+ * {@code SimpleJdbcInsert} to provide the ability to chain multiple ones together
+ * in a "fluent" API style.
  *
  * @author Thomas Risberg
  * @author Juergen Hoeller
+ * @author Sam Brannen
  * @since 2.5
  * @see java.sql.DatabaseMetaData
  * @see org.springframework.jdbc.core.JdbcTemplate
  */
 public class SimpleJdbcInsert extends AbstractJdbcInsert implements SimpleJdbcInsertOperations {
 
 	/**
-	 * Constructor that takes one parameter with the JDBC DataSource to use when creating the
-	 * JdbcTemplate.
+	 * Constructor that accepts the JDBC {@link DataSource} to use when creating
+	 * the {@link JdbcTemplate}.
 	 * @param dataSource the {@code DataSource} to use
 	 * @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
 	 */
@@ -61,7 +63,7 @@ public SimpleJdbcInsert(DataSource dataSource) {
 	}
 
 	/**
-	 * Alternative Constructor that takes one parameter with the JdbcTemplate to be used.
+	 * Alternative constructor that accepts the {@link JdbcTemplate} to be used.
 	 * @param jdbcTemplate the {@code JdbcTemplate} to use
 	 * @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
 	 */