GH-685 - Polishing.

Disable schema support for MySQL as it doesn't know about schemas per database.

General polishing.

Author: odrotbohm

spring-modulith-events/spring-modulith-events-jdbc/pom.xml

@@ -46,6 +46,13 @@
 			<artifactId>spring-boot-autoconfigure</artifactId>
 		</dependency>
 
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-configuration-processor</artifactId>
+			<optional>true</optional>
+		</dependency>
+
+
 		<!-- Testing -->
 
 		<dependency>
@@ -59,13 +66,13 @@
 			<artifactId>spring-boot-starter-jdbc</artifactId>
 			<scope>test</scope>
 		</dependency>
-		
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-web</artifactId>
 			<scope>test</scope>
 		</dependency>
-		
+
 		<dependency>
 			<groupId>jakarta.servlet</groupId>
 			<artifactId>jakarta.servlet-api</artifactId>

spring-modulith-events/spring-modulith-events-jdbc/src/main/java/org/springframework/modulith/events/jdbc/DatabaseSchemaInitializer.java

@@ -21,9 +21,9 @@
 
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.core.io.ResourceLoader;
-import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.JdbcOperations;
 import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
-import org.springframework.util.ObjectUtils;
+import org.springframework.util.Assert;
 
 /**
  * Initializes the DB schema used to store events
@@ -38,55 +38,66 @@ class DatabaseSchemaInitializer implements InitializingBean {
 	private final DataSource dataSource;
 	private final ResourceLoader resourceLoader;
 	private final DatabaseType databaseType;
-	private final JdbcTemplate jdbcTemplate;
+	private final JdbcOperations jdbcOperations;
 	private final JdbcConfigurationProperties properties;
 
 	DatabaseSchemaInitializer(DataSource dataSource, ResourceLoader resourceLoader, DatabaseType databaseType,
-			JdbcTemplate jdbcTemplate, JdbcConfigurationProperties properties) {
+			JdbcOperations jdbcOperations, JdbcConfigurationProperties properties) {
+
+		Assert.isTrue(properties.getSchemaInitialization().isEnabled(),
+				"Schema initialization disabled! Initializer should not have been registered!");
 
 		this.dataSource = dataSource;
 		this.resourceLoader = resourceLoader;
 		this.databaseType = databaseType;
-		this.jdbcTemplate = jdbcTemplate;
+		this.jdbcOperations = jdbcOperations;
 		this.properties = properties;
+
+		properties.verify(databaseType);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
+	 */
 	@Override
 	public void afterPropertiesSet() throws Exception {
 
-		String initialSchema;
 		try (Connection connection = dataSource.getConnection()) {
 
-			initialSchema = connection.getSchema();
+			var initialSchema = connection.getSchema();
+			var schemaName = properties.getSchema();
 
-			String schemaName = properties.getSchema();
-			if (!ObjectUtils.isEmpty(schemaName)) { // A schema name has been specified.
+			if (schemaName != null && !schemaName.isEmpty()) { // A schema name has been specified.
 
-				if (eventPublicationTableExists(jdbcTemplate, schemaName)) {
+				if (eventPublicationTableExists(schemaName)) {
 					return;
 				}
 
-				jdbcTemplate.execute("CREATE SCHEMA IF NOT EXISTS " + schemaName);
-				jdbcTemplate.execute(databaseType.sqlStatementSetSchema(schemaName));
+				jdbcOperations.execute("CREATE SCHEMA IF NOT EXISTS " + schemaName);
+				jdbcOperations.execute(databaseType.getSetSchemaSql(schemaName));
 			}
 
 			var locator = new DatabaseSchemaLocator(resourceLoader);
 			new ResourceDatabasePopulator(locator.getSchemaResource(databaseType)).execute(dataSource);
 
 			// Return to the initial schema.
 			if (initialSchema != null) {
-				jdbcTemplate.execute(databaseType.sqlStatementSetSchema(initialSchema));
+				jdbcOperations.execute(databaseType.getSetSchemaSql(initialSchema));
 			}
 		}
 	}
 
-	private boolean eventPublicationTableExists(JdbcTemplate jdbcTemplate, String schema) {
-		String query = """
+	private boolean eventPublicationTableExists(String schema) {
+
+		var query = """
 				SELECT COUNT(*)
 				FROM information_schema.tables
 				WHERE table_schema = ? AND table_name = 'EVENT_PUBLICATION'
 				""";
-		Integer count = jdbcTemplate.queryForObject(query, Integer.class, schema);
+
+		var count = jdbcOperations.queryForObject(query, Integer.class, schema);
+
 		return count != null && count > 0;
 	}
 }

spring-modulith-events/spring-modulith-events-jdbc/src/main/java/org/springframework/modulith/events/jdbc/DatabaseType.java

@@ -47,6 +47,8 @@ UUID databaseToUUID(Object id) {
 
 	POSTGRES("postgresql", "PostgreSQL");
 
+	static final String SCHEMA_NOT_SUPPORTED = "Setting the schema name not supported on MySQL!";
+
 	static DatabaseType from(String productName) {
 
 		return Arrays.stream(DatabaseType.values())
@@ -77,9 +79,12 @@ String getSchemaResourceFilename() {
 		return "/schema-" + value + ".sql";
 	}
 
-	String sqlStatementSetSchema(String schema) {
+	String getSetSchemaSql(String schema) {
+
 		return switch (this) {
-			case MYSQL, H2, HSQLDB -> "SET SCHEMA " + schema;
+
+			case MYSQL -> throw new IllegalArgumentException(SCHEMA_NOT_SUPPORTED);
+			case H2, HSQLDB -> "SET SCHEMA " + schema;
 			case POSTGRES -> "SET search_path TO " + schema;
 		};
 	}

spring-modulith-events/spring-modulith-events-jdbc/src/main/java/org/springframework/modulith/events/jdbc/JdbcConfigurationProperties.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2024 the original author or authors.
+ * Copyright 2024 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.
@@ -24,39 +24,65 @@
  * Configuration properties for JDBC.
  *
  * @author Raed Ben Hamouda
+ * @author Oliver Drotbohm
  */
 @ConfigurationProperties(prefix = "spring.modulith.events.jdbc")
 class JdbcConfigurationProperties {
 
-	private final boolean schemaInitializationEnabled;
+	private final SchemaInitialization schemaInitialization;
 	private final String schema;
 
 	/**
 	 * Creates a new {@link JdbcConfigurationProperties} instance.
 	 *
-	 * @param schemaInitializationEnabled whether to initialize the JDBC event publication schema. Defaults to {@literal false}.
+	 * @param schemaInitialization whether to initialize the JDBC event publication schema. Defaults to {@literal false}.
 	 * @param schema the schema name of event publication table, can be {@literal null}.
 	 */
 	@ConstructorBinding
-	JdbcConfigurationProperties(@DefaultValue("false") boolean schemaInitializationEnabled, @Nullable String schema) {
+	JdbcConfigurationProperties(SchemaInitialization schemaInitialization, @Nullable String schema) {
 
-		this.schemaInitializationEnabled = schemaInitializationEnabled;
+		this.schemaInitialization = schemaInitialization;
 		this.schema = schema;
 	}
 
 	/**
 	 * Whether to initialize the JDBC event publication schema.
 	 */
-	public boolean isSchemaInitializationEnabled() {
-		return schemaInitializationEnabled;
+	public SchemaInitialization getSchemaInitialization() {
+		return schemaInitialization;
 	}
 
 	/**
 	 * The name of the schema where the event publication table resides.
 	 *
 	 * @return can be {@literal null}.
 	 */
+	@Nullable
 	public String getSchema() {
 		return schema;
 	}
+
+	void verify(DatabaseType databaseType) {
+
+		if (schema != null && databaseType.equals(DatabaseType.MYSQL)) {
+			throw new IllegalStateException(DatabaseType.SCHEMA_NOT_SUPPORTED);
+		}
+	}
+
+	static class SchemaInitialization {
+
+		private final boolean enabled;
+
+		/**
+		 * @param enabled
+		 */
+		@ConstructorBinding
+		SchemaInitialization(@DefaultValue("false") boolean enabled) {
+			this.enabled = enabled;
+		}
+
+		boolean isEnabled() {
+			return enabled;
+		}
+	}
 }