RESOLVED - issue SPR-5917: DataSourceInitializer and namespace support for creating and populating databases

Moved populator to init package and added namespace features

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@2227 50f2f4bb-b051-0410-bef5-90022cba6387

org.springframework.jdbc/src/main/java/org/springframework/jdbc/config/EmbeddedDatabaseBeanDefinitionParser.java

@@ -24,9 +24,9 @@ import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
 import org.springframework.beans.factory.xml.ParserContext;
 import org.springframework.core.io.Resource;
-import org.springframework.jdbc.datasource.embedded.DatabasePopulator;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseFactoryBean;
-import org.springframework.jdbc.datasource.embedded.ResourceDatabasePopulator;
+import org.springframework.jdbc.datasource.init.DatabasePopulator;
+import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
 import org.springframework.util.StringUtils;
 import org.springframework.util.xml.DomUtils;
 import org.w3c.dom.Element;

org.springframework.jdbc/src/main/java/org/springframework/jdbc/config/InitializeDatabaseBeanDefinitionParser.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2002-2009 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.jdbc.config;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
+import org.springframework.core.io.support.ResourcePatternResolver;
+import org.springframework.jdbc.datasource.init.DataSourceInitializer;
+import org.springframework.jdbc.datasource.init.DatabasePopulator;
+import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Element;
+
+/**
+ * {@link org.springframework.beans.factory.xml.BeanDefinitionParser} that parses {@code initialize-database} element and
+ * creates a {@link BeanDefinition} for {@link DataSourceInitializer}. Picks up nested {@code script} elements and
+ * configures a {@link ResourceDatabasePopulator} for them.
+@author Dave Syer
+ *
+ */
+public class InitializeDatabaseBeanDefinitionParser extends AbstractBeanDefinitionParser {
+
+	@Override
+	protected AbstractBeanDefinition parseInternal(Element element, ParserContext context) {
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(DataSourceInitializer.class);
+		builder.addPropertyReference("dataSource", element.getAttribute("data-source"));
+		builder.addPropertyValue("enabled", element.getAttribute("enabled"));
+		setDatabasePopulator(element, context, builder);
+		return getSourcedBeanDefinition(builder, element, context);
+	}
+
+	@Override
+	protected boolean shouldGenerateId() {
+		return true;
+	}
+
+	private void setDatabasePopulator(Element element, ParserContext context, BeanDefinitionBuilder builder) {
+		List<Element> scripts = DomUtils.getChildElementsByTagName(element, "script");
+		if (scripts.size() > 0) {
+			builder.addPropertyValue("databasePopulator", createDatabasePopulator(element, scripts, context));
+		}
+	}
+
+	private DatabasePopulator createDatabasePopulator(Element element, List<Element> scripts, ParserContext context) {
+		ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
+		populator.setIgnoreFailedDrops(element.getAttribute("ignore-failures").equals("DROPS"));
+		populator.setContinueOnError(element.getAttribute("ignore-failures").equals("ALL"));
+		for (Element scriptElement : scripts) {
+			String location = scriptElement.getAttribute("location");
+			ResourceLoader resourceLoader = context.getReaderContext().getResourceLoader();
+			if (resourceLoader instanceof ResourcePatternResolver) {
+				try {
+					List<Resource> resources = new ArrayList<Resource>(Arrays.asList(((ResourcePatternResolver)resourceLoader).getResources(location)));
+					Collections.<Resource>sort(resources, new Comparator<Resource>()  {
+						public int compare(Resource o1, Resource o2) {
+							try {
+								return o1.getURL().toString().compareTo(o2.getURL().toString());
+							} catch (IOException e) {
+								return 0;
+							}
+						}
+					});
+					for (Resource resource : resources) {
+						populator.addScript(resource);					
+					}
+				} catch (IOException e) {
+					context.getReaderContext().error("Cannot locate resources for script from location="+location, scriptElement);
+				}
+			} else {
+				populator.addScript(resourceLoader.getResource(location));
+			}
+		}
+		return populator;
+	}
+
+	private AbstractBeanDefinition getSourcedBeanDefinition(BeanDefinitionBuilder builder, Element source,
+			ParserContext context) {
+		AbstractBeanDefinition definition = builder.getBeanDefinition();
+		definition.setSource(context.extractSource(source));
+		return definition;
+	}
+
+}

org.springframework.jdbc/src/main/java/org/springframework/jdbc/config/JdbcNamespaceHandler.java

@@ -22,10 +22,12 @@ import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
 /**
  * {@link NamespaceHandler} for JDBC configuration namespace.
  * @author Oliver Gierke
+ * @author Dave Syer
  */
 public class JdbcNamespaceHandler extends NamespaceHandlerSupport {
 
 	public void init() {
 		registerBeanDefinitionParser("embedded-database", new EmbeddedDatabaseBeanDefinitionParser());
+		registerBeanDefinitionParser("initialize-database", new InitializeDatabaseBeanDefinitionParser());
 	}
 }

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

@@ -19,6 +19,7 @@ package org.springframework.jdbc.datasource.embedded;
 import org.springframework.core.io.ClassRelativeResourceLoader;
 import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.io.ResourceLoader;
+import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
 
 /**
  * A builder that provides a fluent API for constructing an embedded database.

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

@@ -25,6 +25,7 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.dao.DataAccessResourceFailureException;
+import org.springframework.jdbc.datasource.init.DatabasePopulator;
 import org.springframework.util.Assert;
 
 /**

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.jdbc.datasource.embedded;
+package org.springframework.jdbc.datasource.init;
 
 import org.springframework.core.io.support.EncodedResource;
 

org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/init/DataSourceInitializer.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2002-2009 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.jdbc.datasource.init;
+
+import javax.sql.DataSource;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.Assert;
+
+/**
+ * Used to populate a database during initialization.
+ * @author Dave Syer
+ * @since 3.0
+ * @see DatabasePopulator
+ */
+public class DataSourceInitializer implements InitializingBean {
+
+	private DataSource dataSource;
+
+	private DatabasePopulator databasePopulator;
+
+	private boolean enabled = true;
+
+	/**
+	 * Flag to explicitly enable or disable the database populator.
+	 * 
+	 * @param enabled true if the database populator will be called on startup
+	 */
+	public void setEnabled(boolean enabled) {
+		this.enabled = enabled;
+	}
+
+	/**
+	 * The {@link DatabasePopulator} to use to populate the data source.  Mandatory with no default.
+	 * 
+	 * @param databasePopulator the database populator to use.
+	 */
+	public void setDatabasePopulator(DatabasePopulator databasePopulator) {
+		this.databasePopulator = databasePopulator;
+	}
+
+	/**
+	 * The {@link DataSource} to populate when this component is initialized.  Mandatory with no default.
+	 * 
+	 * @param dataSource the DataSource
+	 */
+	public void setDataSource(DataSource dataSource) {
+		this.dataSource = dataSource;
+	}
+
+	/**
+	 * Use the populator to set up data in the data source.   Both properties are mandatory with no defaults. 
+	 * 
+	 * @see InitializingBean#afterPropertiesSet()
+	 */
+	public void afterPropertiesSet() throws Exception {
+		if (enabled) {
+			Assert.state(dataSource != null, "DataSource must be provided");
+			Assert.state(databasePopulator != null, "DatabasePopulator must be provided");
+			databasePopulator.populate(dataSource.getConnection());
+		}
+	}
+}

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.jdbc.datasource.embedded;
+package org.springframework.jdbc.datasource.init;
 
 import java.sql.Connection;
 import java.sql.SQLException;

org.springframework.jdbc/src/main/java/org/springframework/jdbc/datasource/init/ResourceDatabasePopulator.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.jdbc.datasource.embedded;
+package org.springframework.jdbc.datasource.init;
 
 import java.io.IOException;
 import java.io.LineNumberReader;
@@ -28,7 +28,6 @@ import java.util.List;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-
 import org.springframework.core.io.Resource;
 import org.springframework.core.io.support.EncodedResource;
 import org.springframework.util.StringUtils;
@@ -40,6 +39,7 @@ import org.springframework.util.StringUtils;
  * Call {@link #setSqlScriptEncoding(String)} to set the encoding for all added scripts.<br>
  *
  * @author Keith Donald
+ * @author Dave Syer
  * @since 3.0
  */
 public class ResourceDatabasePopulator implements DatabasePopulator {
@@ -50,6 +50,9 @@ public class ResourceDatabasePopulator implements DatabasePopulator {
 
 	private String sqlScriptEncoding;
 
+	private boolean ignoreFailedDrops = false;
+
+	private boolean continueOnError = false;
 
 	/**
 	 * Add a script to execute to populate the database.
@@ -66,6 +69,29 @@ public class ResourceDatabasePopulator implements DatabasePopulator {
 	public void setScripts(Resource[] scripts) {
 		this.scripts = Arrays.asList(scripts);
 	}
+	
+	/**
+	 * Flag to indicate that all failures in SQL should be logged but not cause a 
+	 * failure.  Defaults to false.
+	 * 
+	 * @param continueOnError the flag value to set
+	 */
+	public void setContinueOnError(boolean continueOnError) {
+		this.continueOnError = continueOnError;
+	}
+
+	/**
+	 * Flag to indicate that a failed SQL <code>DROP</code> statement can be ignored.  
+	 * This is useful for non-embedded databases whose SQL dialect does not support 
+	 * an <code>IF EXISTS</code> clause in a <code>DROP</code>.  The default is false
+	 * so that if it the populator runs accidentally against an existing database it 
+	 * will fail fast when the script starts with a <code>DROP</code>.
+	 * 
+	 * @param ignoreFailedDrops the flag value to set
+	 */
+	public void setIgnoreFailedDrops(boolean ignoreFailedDrops) {
+		this.ignoreFailedDrops = ignoreFailedDrops;
+	}
 
 	/**
 	 * Specify the encoding for SQL scripts, if different from the platform encoding.
@@ -77,30 +103,29 @@ public class ResourceDatabasePopulator implements DatabasePopulator {
 		this.sqlScriptEncoding = sqlScriptEncoding;
 	}
 
-
 	public void populate(Connection connection) throws SQLException {
 		for (Resource script : this.scripts) {
-			executeSqlScript(connection, applyEncodingIfNecessary(script), false);
+			executeSqlScript(connection, applyEncodingIfNecessary(script), continueOnError, ignoreFailedDrops);
 		}
 	}
 
 	private EncodedResource applyEncodingIfNecessary(Resource script) {
 		if (script instanceof EncodedResource) {
 			return (EncodedResource) script;
-		}
-		else {
+		} else {
 			return new EncodedResource(script, this.sqlScriptEncoding);
 		}
 	}
-	
+
 	/**
 	 * Execute the given SQL script. <p>The script will normally be loaded by classpath. There should be one statement
 	 * per line. Any semicolons will be removed. <b>Do not use this method to execute DDL if you expect rollback.</b>
 	 * @param template the SimpleJdbcTemplate with which to perform JDBC operations
 	 * @param resource the resource (potentially associated with a specific encoding) to load the SQL script from.
 	 * @param continueOnError whether or not to continue without throwing an exception in the event of an error.
+	 * @param ignoreFailedDrops whether of not to continue in thw event of specifically an error on a <code>DROP</code>.
 	 */
-	private void executeSqlScript(Connection connection, EncodedResource resource, boolean continueOnError)
+	private void executeSqlScript(Connection connection, EncodedResource resource, boolean continueOnError, boolean ignoreFailedDrops)
 			throws SQLException {
 
 		if (logger.isInfoEnabled()) {
@@ -129,24 +154,21 @@ public class ResourceDatabasePopulator implements DatabasePopulator {
 					if (logger.isDebugEnabled()) {
 						logger.debug(rowsAffected + " rows affected by SQL: " + statement);
 					}
-				}
-				catch (SQLException ex) {
-					if (continueOnError) {
+				} catch (SQLException ex) {
+					boolean dropStatement = statement.trim().toLowerCase().startsWith("drop");
+					if (continueOnError || (dropStatement && ignoreFailedDrops)) {
 						if (logger.isWarnEnabled()) {
 							logger.warn("Line " + lineNumber + " statement failed: " + statement, ex);
 						}
-					}
-					else {
+					} else {
 						throw ex;
 					}
 				}
 			}
-		}
-		finally {
+		} finally {
 			try {
 				stmt.close();
-			}
-			catch (Throwable ex) {
+			} catch (Throwable ex) {
 				logger.debug("Could not close JDBC Statement", ex);
 			}
 		}

org.springframework.jdbc/src/main/resources/org/springframework/jdbc/config/spring-jdbc-3.0.xsd

@@ -1,20 +1,21 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <xsd:schema xmlns="http://www.springframework.org/schema/jdbc"
-		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-		xmlns:beans="http://www.springframework.org/schema/beans"
-		xmlns:tool="http://www.springframework.org/schema/tool"
-		targetNamespace="http://www.springframework.org/schema/jdbc"
-		elementFormDefault="qualified"
-		attributeFormDefault="unqualified">
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:beans="http://www.springframework.org/schema/beans"
+	xmlns:tool="http://www.springframework.org/schema/tool"
+	targetNamespace="http://www.springframework.org/schema/jdbc"
+	elementFormDefault="qualified" attributeFormDefault="unqualified">
 
-	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"/>
-	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool-3.0.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/beans"
+		schemaLocation="http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" />
+	<xsd:import namespace="http://www.springframework.org/schema/tool"
+		schemaLocation="http://www.springframework.org/schema/tool/spring-tool-3.0.xsd" />
 
 	<xsd:element name="embedded-database">
 		<xsd:annotation>
-			<xsd:documentation source="java:org.springframework.jdbc.embedded.EmbeddedDataSourceFactoryBean"><![CDATA[
+			<xsd:documentation
+				source="java:org.springframework.jdbc.embedded.EmbeddedDataSourceFactoryBean"><![CDATA[
 	Creates an embedded database instance and makes it available to other beans as a javax.sql.DataSource.
-			]]></xsd:documentation>		
+			]]></xsd:documentation>
 			<xsd:appinfo>
 				<tool:annotation>
 					<tool:exports type="javax.sql.DataSource" />
@@ -25,33 +26,114 @@
 			<xsd:complexContent>
 				<xsd:extension base="beans:identifiedType">
 					<xsd:sequence>
-						<xsd:element name="script" type="scriptType" minOccurs="0" maxOccurs="unbounded">
+						<xsd:element name="script" type="scriptType"
+							minOccurs="0" maxOccurs="unbounded">
 							<xsd:annotation>
 								<xsd:documentation><![CDATA[
 			A SQL script to execute during embedded database initialization.
 								]]></xsd:documentation>
-							</xsd:annotation>	
+							</xsd:annotation>
 						</xsd:element>
 					</xsd:sequence>
-					<xsd:attribute name="type" type="databaseType" default="HSQL">
+					<xsd:attribute name="type" type="databaseType"
+						default="HSQL">
 						<xsd:annotation>
 							<xsd:documentation><![CDATA[
 			The type of embedded database to create, such as HSQL, H2 or Derby. Defaults to HSQL.
 							]]></xsd:documentation>
-						</xsd:annotation>			
+						</xsd:annotation>
 					</xsd:attribute>
 				</xsd:extension>
 			</xsd:complexContent>
 		</xsd:complexType>
 	</xsd:element>
 
+	<xsd:element name="initialize-database">
+		<xsd:annotation>
+			<xsd:documentation
+				source="java:org.springframework.jdbc.embedded.DataSourceInitializer"><![CDATA[
+	Initializes a database instance with SQL scripts provided in nested <script/> elements.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="script" type="scriptType" minOccurs="1"
+					maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+			A SQL script to execute during database initialization.
+								]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="data-source" type="xsd:string"
+				default="dataSource">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+			A reference to a data source that should be initialized.  Defaults to "dataSource".
+							]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref" />
+						<tool:expected-type type="javax.sql.DataSource" />
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="enabled" type="xsd:string" use="optional"
+				default="true">
+				<xsd:annotation>
+					<xsd:documentation>
+						Is this bean "enabled", that is, will the
+						scripts be executed?
+						Defaults to true, but can be used to switch on
+						and off the
+						initialization depending on the enviroment.
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="ignore-failures" use="optional"
+				default="NONE">
+				<xsd:annotation>
+					<xsd:documentation>
+						Should failed SQL statements be ignored during initialization?
+					</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="NONE">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+						Do not ignore failures (the default)
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="DROPS">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+						Ignore failed DROP statements
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="ALL">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+						Ignore all failures
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
 	<xsd:complexType name="scriptType">
 		<xsd:attribute name="location" type="xsd:string">
 			<xsd:annotation>
-				<xsd:documentation source="java:org.springframework.core.io.Resource"><![CDATA[
-	The resource location of the SQL script to execute.
+				<xsd:documentation><![CDATA[
+	The resource location of an SQL script to execute.  Can be single script location or 
+	a pattern (e.g. classpath:/com/foo/sql/*-data.sql).
 				]]></xsd:documentation>
-			</xsd:annotation>		
+			</xsd:annotation>
 		</xsd:attribute>
 	</xsd:complexType>
 
@@ -62,21 +144,21 @@
 					<xsd:documentation><![CDATA[
 			Hyper SQL Java Database Engine
 					]]></xsd:documentation>
-				</xsd:annotation>	
+				</xsd:annotation>
 			</xsd:enumeration>
 			<xsd:enumeration value="H2">
 				<xsd:annotation>
 					<xsd:documentation><![CDATA[
 			H2 Java Database Engine
 					]]></xsd:documentation>
-				</xsd:annotation>	
+				</xsd:annotation>
 			</xsd:enumeration>
 			<xsd:enumeration value="DERBY">
 				<xsd:annotation>
 					<xsd:documentation><![CDATA[
 			Derby Java Database Engine
 					]]></xsd:documentation>
-				</xsd:annotation>	
+				</xsd:annotation>
 			</xsd:enumeration>
 		</xsd:restriction>
 	</xsd:simpleType>

org.springframework.jdbc/src/test/java/org/springframework/jdbc/config/InitializeDatabaseIntegrationTest.java

@@ -0,0 +1,100 @@
+package org.springframework.jdbc.config;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import java.util.Map;
+
+import javax.sql.DataSource;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.jdbc.BadSqlGrammarException;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+public class InitializeDatabaseIntegrationTest {
+
+	private String enabled;
+	private ClassPathXmlApplicationContext context;
+
+	@Before
+	public void init() {
+		enabled = System.setProperty("ENABLED", "true");
+	}
+
+	@After
+	public void after() {
+		if (enabled != null) {
+			System.setProperty("ENABLED", enabled);
+		} else {
+			System.clearProperty("ENABLED");
+		}
+		if (context != null) {
+			context.close();
+		}
+	}
+
+	@Test
+	public void testCreateEmbeddedDatabase() throws Exception {
+		context = new ClassPathXmlApplicationContext("org/springframework/jdbc/config/jdbc-initialize-config.xml");
+		assertCorrectSetup(context.getBean("dataSource", DataSource.class));
+	}
+
+	@Test(expected = BadSqlGrammarException.class)
+	public void testDisableCreateEmbeddedDatabase() throws Exception {
+		System.setProperty("ENABLED", "false");
+		context = new ClassPathXmlApplicationContext("org/springframework/jdbc/config/jdbc-initialize-config.xml");
+		assertCorrectSetup(context.getBean("dataSource", DataSource.class));
+	}
+
+	@Test
+	public void testIgnoreFailedDrops() throws Exception {
+		context = new ClassPathXmlApplicationContext("org/springframework/jdbc/config/jdbc-initialize-fail-config.xml");
+		assertCorrectSetup(context.getBean("dataSource", DataSource.class));
+	}
+
+	@Test
+	public void testScriptNameWithPattern() throws Exception {
+		context = new ClassPathXmlApplicationContext("org/springframework/jdbc/config/jdbc-initialize-pattern-config.xml");
+		DataSource dataSource = context.getBean("dataSource", DataSource.class);
+		assertCorrectSetup(dataSource);
+		JdbcTemplate t = new JdbcTemplate(dataSource);
+		assertEquals("Dave", t.queryForObject("select name from T_TEST", String.class));
+	}
+
+	@Test
+	public void testCacheInitialization() throws Exception {
+		context = new ClassPathXmlApplicationContext("org/springframework/jdbc/config/jdbc-initialize-cache-config.xml");
+		assertCorrectSetup(context.getBean("dataSource", DataSource.class));
+		CacheData cache = context.getBean(CacheData.class);
+		assertEquals(1, cache.getCachedData().size());
+	}
+
+	private void assertCorrectSetup(DataSource dataSource) {
+		JdbcTemplate t = new JdbcTemplate(dataSource);
+		assertEquals(1, t.queryForInt("select count(*) from T_TEST"));
+	}
+	
+	public static class CacheData implements InitializingBean {
+
+		private JdbcTemplate jdbcTemplate;
+		private List<Map<String,Object>> cache;
+		
+		public void setDataSource(DataSource dataSource) {
+			this.jdbcTemplate = new JdbcTemplate(dataSource);
+		}
+		
+		public List<Map<String,Object>> getCachedData() {
+			return cache;
+		}
+
+		public void afterPropertiesSet() throws Exception {
+			cache = jdbcTemplate.queryForList("SELECT * FROM T_TEST");
+		}
+		
+	}
+
+}

org.springframework.jdbc/src/test/java/org/springframework/jdbc/datasource/embedded/EmbeddedDatabaseBuilderTests.java

@@ -7,6 +7,7 @@ import static org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType.
 
 import org.junit.Test;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.init.CannotReadScriptException;
 
 public class EmbeddedDatabaseBuilderTests {
 

org.springframework.jdbc/src/test/java/org/springframework/jdbc/datasource/embedded/EmbeddedDatabaseFactoryBeanTests.java

@@ -8,6 +8,7 @@ import org.junit.Test;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
 
 public class EmbeddedDatabaseFactoryBeanTests {
 

org.springframework.jdbc/src/test/java/org/springframework/jdbc/datasource/embedded/EmbeddedDatabaseFactoryTests.java

@@ -5,6 +5,7 @@ import static org.junit.Assert.assertTrue;
 import java.sql.Connection;
 
 import org.junit.Test;
+import org.springframework.jdbc.datasource.init.DatabasePopulator;
 
 public class EmbeddedDatabaseFactoryTests {
 	

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/config/db-drops.sql

@@ -0,0 +1 @@
+drop table T_TEST;

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/config/db-update-data.sql

@@ -0,0 +1 @@
+update T_TEST set NAME='Dave' where name='Keith';

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/config/jdbc-config.xml

@@ -6,18 +6,18 @@
 		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">
 
 	<jdbc:embedded-database id="dataSource" type="HSQL">
-		<jdbc:script location="classpath:org/springframework/jdbc/datasource/embedded/db-schema.sql"/>
-		<jdbc:script location="classpath:org/springframework/jdbc/datasource/embedded/db-test-data.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-schema.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-test-data.sql"/>
 	</jdbc:embedded-database>
 	
 	<jdbc:embedded-database id="h2DataSource" type="H2">
-		<jdbc:script location="classpath:org/springframework/jdbc/datasource/embedded/db-schema.sql"/>
-		<jdbc:script location="classpath:org/springframework/jdbc/datasource/embedded/db-test-data.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-schema.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-test-data.sql"/>
 	</jdbc:embedded-database>
 	
 	<jdbc:embedded-database id="derbyDataSource" type="DERBY">
-		<jdbc:script location="classpath:org/springframework/jdbc/datasource/embedded/db-schema-derby.sql"/>
-		<jdbc:script location="classpath:org/springframework/jdbc/datasource/embedded/db-test-data.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-schema-derby.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-test-data.sql"/>
 	</jdbc:embedded-database>
 	
 </beans>

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/config/jdbc-initialize-cache-config.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">
+
+	<jdbc:embedded-database id="dataSource" type="HSQL"/>
+	
+	<jdbc:initialize-database data-source="dataSource">
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-schema.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-test-data.sql"/>
+	</jdbc:initialize-database>
+
+	<!-- This cache relies on data created in the initialize-database element.  It works fine
+	if the bean definitions are registered in the right order.  (Could possibly be fixed later.) -->	
+	<bean class="org.springframework.jdbc.config.InitializeDatabaseIntegrationTest$CacheData">
+		<property name="dataSource" ref="dataSource"/>
+	</bean>
+
+</beans>

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/config/jdbc-initialize-config.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">
+
+	<jdbc:embedded-database id="dataSource" type="HSQL"/>
+	
+	<jdbc:initialize-database data-source="dataSource" enabled="#{systemProperties['ENABLED']}">
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-schema.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-test-data.sql"/>
+	</jdbc:initialize-database>
+
+</beans>

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/config/jdbc-initialize-fail-config.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">
+
+	<jdbc:embedded-database id="dataSource" type="HSQL"/>
+	
+	<jdbc:initialize-database data-source="dataSource" ignore-failures="DROPS">
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-drops.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-schema.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-test-data.sql"/>
+	</jdbc:initialize-database>
+
+</beans>

org.springframework.jdbc/src/test/resources/org/springframework/jdbc/config/jdbc-initialize-pattern-config.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">
+
+	<jdbc:embedded-database id="dataSource" type="HSQL"/>
+	
+	<jdbc:initialize-database data-source="dataSource">
+		<jdbc:script location="classpath:org/springframework/jdbc/config/db-schema.sql"/>
+		<jdbc:script location="classpath:org/springframework/jdbc/config/*-data.sql"/>
+	</jdbc:initialize-database>
+
+</beans>