eliminated dependency on jdbc core

Author: Keith Donald

eclipse-code-formatter.prefs

@@ -1,4 +1,4 @@
-#Thu Dec 18 06:35:47 PST 2008
+#Wed May 06 02:42:56 EDT 2009
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
@@ -57,15 +57,15 @@ org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
 org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
 org.eclipse.jdt.core.formatter.comment.format_block_comments=true
 org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_html=false
 org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
 org.eclipse.jdt.core.formatter.comment.format_line_comments=true
 org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
-org.eclipse.jdt.core.formatter.comment.line_length=80
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=false
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=false
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=do not insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
+org.eclipse.jdt.core.formatter.comment.line_length=120
 org.eclipse.jdt.core.formatter.compact_else_if=true
 org.eclipse.jdt.core.formatter.continuation_indentation=2
 org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
@@ -256,7 +256,7 @@ org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
 org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
 org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
 org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=80
+org.eclipse.jdt.core.formatter.lineSplit=120
 org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
 org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
 org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0

org.springframework.jdbc/.settings/org.eclipse.jdt.core.prefs

@@ -1,4 +1,4 @@
-#Thu Dec 18 06:35:47 PST 2008
+#Wed May 06 02:42:56 EDT 2009
 eclipse.preferences.version=1
-formatter_profile=org.eclipse.jdt.ui.default.eclipse_profile
+formatter_profile=_Spring
 formatter_settings_version=11

org.springframework.jdbc/.settings/org.eclipse.jdt.ui.prefs

@@ -0,0 +1,10 @@
+package org.springframework.jdbc.datasource.embedded;
+
+import org.springframework.core.io.support.EncodedResource;
+
+public class CannotReadScriptException extends RuntimeException {
+
+	public CannotReadScriptException(EncodedResource resource, Throwable cause) {
+		super("Cannot read SQL script from " + resource, cause);
+	}
+}

org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/CannotReadScriptException.java

@@ -15,8 +15,8 @@
  */
 package org.springframework.jdbc.datasource.embedded;
 
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.JdbcTemplate;
+import java.sql.Connection;
+import java.sql.SQLException;
 
 /**
  * Strategy for populating a database with data.
@@ -27,8 +27,8 @@ public interface DatabasePopulator {
 
 	/**
 	 * Populate the database using the JDBC-based data access template provided.
-	 * @param template the data access template to use to populate the db; already configured and ready to use
-	 * @throws DataAccessException if an unrecoverable data access exception occurs during database population
+	 * @param connection the JDBC connection to use to populate the db; already configured and ready to use
+	 * @throws SQLException if an unrecoverable data access exception occurs during database population
 	 */
-	void populate(JdbcTemplate template);
+	void populate(Connection connection) throws SQLException;
 }

org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/DatabasePopulator.java

@@ -23,24 +23,20 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DataSourceTransactionManager;
-import org.springframework.transaction.TransactionStatus;
-import org.springframework.transaction.support.TransactionCallbackWithoutResult;
-import org.springframework.transaction.support.TransactionTemplate;
 import org.springframework.util.Assert;
 
 /**
- * Returns a {@link EmbeddedDatabase} instance pre-populated with test data.
- * When the database is returned, callers are guaranteed that the database schema and test data will have already been loaded.
+ * Returns a {@link EmbeddedDatabase} instance pre-populated with test data. When the database is returned, callers are
+ * guaranteed that the database schema and test data will have already been loaded.
+ * <p>
+ * Can be configured:<br>
+ * Call {@link #setDatabaseName(String)} to change the name of the database.<br>
+ * Call {@link #setDatabaseType(EmbeddedDatabaseType)} to set the database type if you wish to use one of the supported types.<br>
+ * Call {@link #setDatabaseConfigurer(EmbeddedDatabaseConfigurer)} to set a configuration strategy for your own embedded database type.<br>
+ * Call {@link #setDatabasePopulator(DatabasePopulator)} to change the algorithm used to populate the database.<br>
+ * Call {@link #setDataSourceFactory(DataSourceFactory)} to change the type of DataSource used to connect to the database.<br>
+ * Call {@link #getDatabase()} to get the {@link EmbeddedDatabase} instance.<br>
  * 
- * Can be configured.
- * Call {@link #setDatabaseName(String)} to change the name of the  database.
- * Call {@link #setDatabaseType(EmbeddedDatabaseType)} to set the database type if you wish to use one of the supported types.
- * Call {@link #setDatabaseConfigurer(EmbeddedDatabaseConfigurer)} to set a configuration strategy for your own embedded database type.
- * Call {@link #setDatabasePopulator(DatabasePopulator)} to change the algorithm used to populate the database.
- * Call {@link #setDataSourceFactory(DataSourceFactory)} to change the type of DataSource used to connect to the database.
- * Call {@link #getDatabase()} to get the {@link EmbeddedDatabase} instance.
  * @author Keith Donald
  */
 public class EmbeddedDatabaseFactory {
@@ -50,36 +46,34 @@ public class EmbeddedDatabaseFactory {
 	private String databaseName;
 
 	private DataSourceFactory dataSourceFactory;
-	
+
 	private EmbeddedDatabaseConfigurer databaseConfigurer;
 
 	private DatabasePopulator databasePopulator;
 
 	private DataSource dataSource;
-	
+
 	/**
-	 * Creates a default {@link EmbeddedDatabaseFactory}.
-	 * Calling {@link #getDatabase()} will create a embedded HSQL database of name 'testdb'.
+	 * Creates a default {@link EmbeddedDatabaseFactory}. Calling {@link #getDatabase()} will create a embedded HSQL
+	 * database of name 'testdb'.
 	 */
 	public EmbeddedDatabaseFactory() {
 		setDatabaseName("testdb");
 		setDatabaseType(EmbeddedDatabaseType.HSQL);
 		setDataSourceFactory(new SimpleDriverDataSourceFactory());
 	}
-	
+
 	/**
-	 * Sets the name of the database.
-	 * Defaults to 'testdb'.
+	 * Sets the name of the database. Defaults to 'testdb'.
 	 * @param name of the test database
 	 */
 	public void setDatabaseName(String name) {
 		Assert.notNull(name, "The testDatabaseName is required");
 		databaseName = name;
 	}
-	
+
 	/**
-	 * Sets the type of embedded database to use.
-	 * Call this when you wish to configure one of the pre-supported types.
+	 * Sets the type of embedded database to use. Call this when you wish to configure one of the pre-supported types.
 	 * Defaults to HSQL.
 	 * @param type the test database type
 	 */
@@ -88,27 +82,26 @@ public void setDatabaseType(EmbeddedDatabaseType type) {
 	}
 
 	/**
-	 * Sets the strategy that will be used to configure the embedded database instance.
-	 * Call this when you wish to use an embedded database type not already supported.
+	 * Sets the strategy that will be used to configure the embedded database instance. Call this when you wish to use
+	 * an embedded database type not already supported.
 	 * @param configurer the embedded database configurer
 	 */
 	public void setDatabaseConfigurer(EmbeddedDatabaseConfigurer configurer) {
 		this.databaseConfigurer = configurer;
 	}
-	
+
 	/**
-	 * Sets the strategy that will be used to populate the embedded database.
-	 * Defaults to null.
-	 * @param populator the database populator 
+	 * Sets the strategy that will be used to populate the embedded database. Defaults to null.
+	 * @param populator the database populator
 	 */
 	public void setDatabasePopulator(DatabasePopulator populator) {
 		Assert.notNull(populator, "The DatabasePopulator is required");
 		databasePopulator = populator;
 	}
 
 	/**
-	 * Sets the factory to use to create the DataSource instance that connects to the embedded database.
-	 * Defaults to {@link SimpleDriverDataSourceFactory}.
+	 * Sets the factory to use to create the DataSource instance that connects to the embedded database. Defaults to
+	 * {@link SimpleDriverDataSourceFactory}.
 	 * @param dataSourceFactory the data source factory
 	 */
 	public void setDataSourceFactory(DataSourceFactory dataSourceFactory) {
@@ -129,7 +122,7 @@ public EmbeddedDatabase getDatabase() {
 	}
 
 	// subclassing hooks
-	
+
 	protected void initDataSource() {
 		// create the embedded database source first
 		if (logger.isInfoEnabled()) {
@@ -146,26 +139,27 @@ protected void initDataSource() {
 	protected DataSource getDataSource() {
 		return dataSource;
 	}
-	
+
 	protected void shutdownDataSource() {
 		if (dataSource != null) {
 			databaseConfigurer.shutdown(dataSource);
 			dataSource = null;
 		}
 	}
-	
+
 	// internal helper methods
 
 	private void populateDatabase() {
-		TransactionTemplate template = new TransactionTemplate(new DataSourceTransactionManager(dataSource));
-		template.execute(new TransactionCallbackWithoutResult() {
-			@Override
-			protected void doInTransactionWithoutResult(TransactionStatus status) {
-				databasePopulator.populate(new JdbcTemplate(dataSource));
-			}
-		});
+		Connection connection = JdbcUtils.getConnection(dataSource);
+		try {
+			databasePopulator.populate(connection);
+		} catch (SQLException e) {
+			throw new RuntimeException("SQLException occurred populating embedded database", e);
+		} finally {
+			JdbcUtils.closeConnection(connection);
+		}
 	}
-	
+
 	private class EmbeddedDataSourceProxy implements EmbeddedDatabase {
 		private DataSource dataSource;
 
@@ -177,8 +171,7 @@ public Connection getConnection() throws SQLException {
 			return dataSource.getConnection();
 		}
 
-		public Connection getConnection(String username, String password)
-				throws SQLException {
+		public Connection getConnection(String username, String password) throws SQLException {
 			return dataSource.getConnection(username, password);
 		}
 
@@ -205,11 +198,11 @@ public boolean isWrapperFor(Class<?> iface) throws SQLException {
 		public <T> T unwrap(Class<T> iface) throws SQLException {
 			return dataSource.unwrap(iface);
 		}
-		
+
 		public void shutdown() {
 			shutdownDataSource();
 		}
 
 	}
-	
+
 }

org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/EmbeddedDatabaseFactory.java

@@ -15,13 +15,20 @@
  */
 package org.springframework.jdbc.datasource.embedded;
 
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+
 import javax.sql.DataSource;
 
-import org.springframework.jdbc.core.JdbcTemplate;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.springframework.util.ClassUtils;
 
 public class HsqlEmbeddedDatabaseConfigurer implements EmbeddedDatabaseConfigurer {
 
+	private static final Log logger = LogFactory.getLog(HsqlEmbeddedDatabaseConfigurer.class);
+
 	private static HsqlEmbeddedDatabaseConfigurer INSTANCE;
 
 	public static synchronized HsqlEmbeddedDatabaseConfigurer getInstance() throws ClassNotFoundException {
@@ -40,7 +47,18 @@ public void configureConnectionProperties(ConnectionProperties properties, Strin
 	}
 
 	public void shutdown(DataSource dataSource) {
-		new JdbcTemplate(dataSource).execute("SHUTDOWN");
+		Connection connection = JdbcUtils.getConnection(dataSource);
+		Statement stmt = null;
+		try {
+			stmt = connection.createStatement();
+			stmt.execute("SHUTDOWN");
+		} catch (SQLException e) {
+			if (logger.isWarnEnabled()) {
+				logger.warn("Could not shutdown in-memory HSQL database", e);
+			}
+		} finally {
+			JdbcUtils.closeStatement(stmt);
+		}
 	}
 
 }

org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/embedded/HsqlEmbeddedDatabaseConfigurer.java

@@ -0,0 +1,59 @@
+package org.springframework.jdbc.datasource.embedded;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import javax.sql.DataSource;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.jdbc.CannotGetJdbcConnectionException;
+
+/**
+ * Helper JDBC utilities used by other classes in this package. There is some duplication here with JdbcUtils in
+ * jdbc.support package. We may want to consider simply using that. Package private for now.
+ * @author Keith Donald
+ */
+final class JdbcUtils {
+
+	private static Log logger = LogFactory.getLog(EmbeddedDatabaseFactory.class);
+
+	private JdbcUtils() {
+
+	}
+
+	public static Connection getConnection(DataSource dataSource) {
+		try {
+			return dataSource.getConnection();
+		} catch (SQLException ex) {
+			throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
+		}
+	}
+
+	public static void closeConnection(Connection connection) {
+		if (connection != null) {
+			try {
+				connection.close();
+			} catch (SQLException ex) {
+				logger.debug("Could not close JDBC Connection", ex);
+			} catch (Throwable ex) {
+				// We don't trust the JDBC driver: It might throw RuntimeException or Error.
+				logger.debug("Unexpected exception on closing JDBC Connection", ex);
+			}
+		}
+	}
+
+	public static void closeStatement(Statement stmt) {
+		if (stmt != null) {
+			try {
+				stmt.close();
+			} catch (SQLException ex) {
+				logger.debug("Could not close JDBC Statement", ex);
+			} catch (Throwable ex) {
+				// We don't trust the JDBC driver: It might throw RuntimeException or Error.
+				logger.debug("Unexpected exception on closing JDBC Statement", ex);
+			}
+		}
+	}
+}