#20 - Add Dialect initial support for H2, PostgreSQL, and Microsoft SQL Server.

We now provide dialect support for H2, PostgreSQL, and Microsoft SQL Server databases, configurable through AbstractR2dbcConfiguration. By default, we obtain the Dialect by inspecting ConnectionFactoryMetadata to identify the database and the most likely dialect to use.

BindableOperation encapsulates statements/queries that can accept parameters. Use BindableOperation for statements through DatabaseClient.
Extract SQL creation.

Split integration test into abstract base class that can be implemented with a database-specific test class.

Original pull request: #24.

Author: mp911de

pom.xml

@@ -30,8 +30,11 @@
 		<degraph-check.version>0.1.4</degraph-check.version>
 		<hsqldb.version>2.4.1</hsqldb.version>
 		<postgresql.version>42.2.5</postgresql.version>
+		<mssql-jdbc.version>7.1.2.jre8-preview</mssql-jdbc.version>
 		<r2dbc-spi.version>1.0.0.M6</r2dbc-spi.version>
 		<r2dbc-postgresql.version>1.0.0.M6</r2dbc-postgresql.version>
+		<r2dbc-h2.version>1.0.0.M6</r2dbc-h2.version>
+		<r2dbc-mssql.version>1.0.0.M6</r2dbc-mssql.version>
 		<testcontainers.version>1.10.1</testcontainers.version>
 
 	</properties>
@@ -235,13 +238,33 @@
 			<scope>test</scope>
 		</dependency>
 
+		<dependency>
+			<groupId>com.microsoft.sqlserver</groupId>
+			<artifactId>mssql-jdbc</artifactId>
+			<version>${mssql-jdbc.version}</version>
+		</dependency>
+
 		<dependency>
 			<groupId>io.r2dbc</groupId>
 			<artifactId>r2dbc-postgresql</artifactId>
 			<version>${r2dbc-postgresql.version}</version>
 			<scope>test</scope>
 		</dependency>
 
+		<dependency>
+			<groupId>io.r2dbc</groupId>
+			<artifactId>r2dbc-h2</artifactId>
+			<version>${r2dbc-h2.version}</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>io.r2dbc</groupId>
+			<artifactId>r2dbc-mssql</artifactId>
+			<version>${r2dbc-mssql.version}</version>
+			<scope>test</scope>
+		</dependency>
+
 		<dependency>
 			<groupId>de.schauderhaft.degraph</groupId>
 			<artifactId>degraph-check</artifactId>

src/main/java/org/springframework/data/r2dbc/repository/config/AbstractR2dbcConfiguration.java renamed to src/main/java/org/springframework/data/r2dbc/config/AbstractR2dbcConfiguration.java

@@ -13,13 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.springframework.data.r2dbc.repository.config;
+package org.springframework.data.r2dbc.config;
+
+import io.r2dbc.spi.ConnectionFactory;
 
 import java.util.Optional;
 
-import io.r2dbc.spi.ConnectionFactory;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.data.r2dbc.dialect.Database;
+import org.springframework.data.r2dbc.dialect.Dialect;
 import org.springframework.data.r2dbc.function.DatabaseClient;
 import org.springframework.data.r2dbc.function.DefaultReactiveDataAccessStrategy;
 import org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy;
@@ -37,7 +40,7 @@
  * @author Mark Paluch
  * @see ConnectionFactory
  * @see DatabaseClient
- * @see EnableR2dbcRepositories
+ * @see org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories
  */
 @Configuration
 public abstract class AbstractR2dbcConfiguration {
@@ -50,6 +53,24 @@ public abstract class AbstractR2dbcConfiguration {
 	 */
 	public abstract ConnectionFactory connectionFactory();
 
+	/**
+	 * Return a {@link Dialect} for the given {@link ConnectionFactory}. This method attempts to resolve a {@link Dialect}
+	 * from {@link io.r2dbc.spi.ConnectionFactoryMetadata}. Override this method to specify a dialect instead of
+	 * attempting to resolve one.
+	 *
+	 * @param connectionFactory the configured {@link ConnectionFactory}.
+	 * @return the resolved {@link Dialect}.
+	 * @throws UnsupportedOperationException if the {@link Dialect} cannot be determined.
+	 */
+	public Dialect getDialect(ConnectionFactory connectionFactory) {
+
+		return Database.findDatabase(connectionFactory)
+				.orElseThrow(() -> new UnsupportedOperationException(
+						String.format("Cannot determine a dialect for %s using %s. Please provide a Dialect.",
+								connectionFactory.getMetadata().getName(), connectionFactory)))
+				.latestDialect();
+	}
+
 	/**
 	 * Register a {@link DatabaseClient} using {@link #connectionFactory()} and {@link RelationalMappingContext}.
 	 *
@@ -86,18 +107,21 @@ public RelationalMappingContext r2dbcMappingContext(Optional<NamingStrategy> nam
 	}
 
 	/**
-	 * Creates a {@link ReactiveDataAccessStrategy} using the configured {@link #r2dbcMappingContext(Optional) RelationalMappingContext}.
+	 * Creates a {@link ReactiveDataAccessStrategy} using the configured {@link #r2dbcMappingContext(Optional)
+	 * RelationalMappingContext}.
 	 *
 	 * @param mappingContext the configured {@link RelationalMappingContext}.
 	 * @return must not be {@literal null}.
 	 * @see #r2dbcMappingContext(Optional)
+	 * @see #getDialect(ConnectionFactory)
 	 * @throws IllegalArgumentException if any of the {@literal mappingContext} is {@literal null}.
 	 */
 	@Bean
 	public ReactiveDataAccessStrategy reactiveDataAccessStrategy(RelationalMappingContext mappingContext) {
 
 		Assert.notNull(mappingContext, "MappingContext must not be null!");
-		return new DefaultReactiveDataAccessStrategy(new BasicRelationalConverter(mappingContext));
+		return new DefaultReactiveDataAccessStrategy(getDialect(connectionFactory()),
+				new BasicRelationalConverter(mappingContext));
 	}
 
 	/**

src/main/java/org/springframework/data/r2dbc/config/package-info.java

@@ -0,0 +1,6 @@
+/**
+ * Configuration classes for Spring Data R2DBC.
+ */
+@org.springframework.lang.NonNullApi
+@org.springframework.lang.NonNullFields
+package org.springframework.data.r2dbc.config;

src/main/java/org/springframework/data/r2dbc/dialect/BindMarker.java

@@ -28,7 +28,7 @@ public interface BindMarker {
 	 *          {@literal null} values.
 	 * @see Statement#bind
 	 */
-	void bindValue(Statement<?> statement, Object value);
+	void bind(Statement<?> statement, Object value);
 
 	/**
 	 * Bind a {@literal null} value to the {@link Statement} using the underlying binding strategy.
@@ -37,6 +37,5 @@ public interface BindMarker {
 	 * @param valueType value type, must not be {@literal null}.
 	 * @see Statement#bindNull
 	 */
-
 	void bindNull(Statement<?> statement, Class<?> valueType);
 }

src/main/java/org/springframework/data/r2dbc/dialect/Database.java

@@ -0,0 +1,92 @@
+package org.springframework.data.r2dbc.dialect;
+
+import io.r2dbc.spi.ConnectionFactory;
+import io.r2dbc.spi.ConnectionFactoryMetadata;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Optional;
+
+import org.springframework.util.Assert;
+
+/**
+ * Enumeration of known Databases for offline {@link Dialect} resolution. R2DBC {@link io.r2dbc.spi.ConnectionFactory}
+ * provides {@link io.r2dbc.spi.ConnectionFactoryMetadata metadata} that allows resolving an appropriate {@link Dialect}
+ * if none was configured explicitly.
+ *
+ * @author Mark Paluch
+ */
+public enum Database {
+
+	POSTGRES {
+		@Override
+		public String driverName() {
+			return "PostgreSQL";
+		}
+
+		@Override
+		public Dialect latestDialect() {
+			return PostgresDialect.INSTANCE;
+		}
+	},
+
+	SQL_SERVER {
+		@Override
+		public String driverName() {
+			return "Microsoft SQL Server";
+		}
+
+		@Override
+		public Dialect latestDialect() {
+			return SqlServerDialect.INSTANCE;
+		}
+	},
+
+	H2 {
+		@Override
+		public String driverName() {
+			return "H2";
+		}
+
+		@Override
+		public Dialect latestDialect() {
+			return H2Dialect.INSTANCE;
+		}
+	};
+
+	/**
+	 * Find a {@link Database} type using {@link ConnectionFactory} and its metadata.
+	 *
+	 * @param connectionFactory must not be {@literal null}.
+	 * @return the resolved {@link Database} or {@link Optional#empty()} if the database type cannot be determined from
+	 *         {@link ConnectionFactory}.
+	 */
+	public static Optional<Database> findDatabase(ConnectionFactory connectionFactory) {
+
+		Assert.notNull(connectionFactory, "ConnectionFactor must not be null!");
+
+		ConnectionFactoryMetadata metadata = connectionFactory.getMetadata();
+
+		return Arrays.stream(values()).filter(it -> matches(metadata, it.driverName())).findFirst();
+	}
+
+	private static boolean matches(ConnectionFactoryMetadata metadata, String databaseType) {
+		return metadata.getName().toLowerCase(Locale.ENGLISH).contains(databaseType.toLowerCase(Locale.ENGLISH));
+	}
+
+	/**
+	 * Returns the driver name.
+	 *
+	 * @return the driver name.
+	 * @see ConnectionFactoryMetadata#getName()
+	 */
+	public abstract String driverName();
+
+	/**
+	 * Returns the latest {@link Dialect} for the underlying database.
+	 *
+	 * @return the latest {@link Dialect} for the underlying database.
+	 */
+	public abstract Dialect latestDialect();
+
+}

src/main/java/org/springframework/data/r2dbc/dialect/Dialect.java

@@ -0,0 +1,31 @@
+package org.springframework.data.r2dbc.dialect;
+
+/**
+ * Represents a dialect that is implemented by a particular database.
+ *
+ * @author Mark Paluch
+ */
+public interface Dialect {
+
+	/**
+	 * Returns the {@link BindMarkersFactory} used by this dialect.
+	 *
+	 * @return the {@link BindMarkersFactory} used by this dialect.
+	 */
+	BindMarkersFactory getBindMarkersFactory();
+
+	/**
+	 * Returns the statement to include for returning generated keys. The returned query is directly appended to
+	 * {@code INSERT} statements.
+	 *
+	 * @return the statement to include for returning generated keys.
+	 */
+	String returnGeneratedKeys();
+
+	/**
+	 * Return the {@link LimitClause} used by this dialect.
+	 *
+	 * @return the {@link LimitClause} used by this dialect.
+	 */
+	LimitClause limit();
+}

src/main/java/org/springframework/data/r2dbc/dialect/H2Dialect.java

@@ -0,0 +1,23 @@
+package org.springframework.data.r2dbc.dialect;
+
+/**
+ * An SQL dialect for H2 in Postgres Compatibility mode.
+ *
+ * @author Mark Paluch
+ */
+public class H2Dialect extends PostgresDialect {
+
+	/**
+	 * Singleton instance.
+	 */
+	public static final H2Dialect INSTANCE = new H2Dialect();
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.r2dbc.dialect.Dialect#returnGeneratedKeys()
+	 */
+	@Override
+	public String returnGeneratedKeys() {
+		return "";
+	}
+}

src/main/java/org/springframework/data/r2dbc/dialect/IndexedBindMarkers.java

@@ -18,6 +18,7 @@ class IndexedBindMarkers implements BindMarkers {
 	// access via COUNTER_INCREMENTER
 	@SuppressWarnings("unused") private volatile int counter;
 
+	private final int offset;
 	private final String prefix;
 
 	/**
@@ -29,9 +30,10 @@ class IndexedBindMarkers implements BindMarkers {
 	IndexedBindMarkers(String prefix, int beginWith) {
 		this.counter = beginWith;
 		this.prefix = prefix;
+		this.offset = 0 - beginWith;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.dialect.BindMarkers#next()
 	 */
@@ -40,7 +42,7 @@ public BindMarker next() {
 
 		int index = COUNTER_INCREMENTER.getAndIncrement(this);
 
-		return new IndexedBindMarker(prefix + "" + index, index);
+		return new IndexedBindMarker(prefix + "" + index, index + offset);
 	}
 
 	/**
@@ -57,7 +59,7 @@ static class IndexedBindMarker implements BindMarker {
 			this.index = index;
 		}
 
-		/* 
+		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.data.r2dbc.dialect.BindMarker#getPlaceholder()
 		 */
@@ -66,16 +68,16 @@ public String getPlaceholder() {
 			return placeholder;
 		}
 
-		/* 
+		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.data.r2dbc.dialect.BindMarker#bindValue(io.r2dbc.spi.Statement, java.lang.Object)
 		 */
 		@Override
-		public void bindValue(Statement<?> statement, Object value) {
+		public void bind(Statement<?> statement, Object value) {
 			statement.bind(this.index, value);
 		}
 
-		/* 
+		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.data.r2dbc.dialect.BindMarker#bindNull(io.r2dbc.spi.Statement, java.lang.Class)
 		 */

src/main/java/org/springframework/data/r2dbc/dialect/LimitClause.java

@@ -0,0 +1,42 @@
+package org.springframework.data.r2dbc.dialect;
+
+/**
+ * A clause representing Dialect-specific {@code LIMIT}.
+ *
+ * @author Mark Paluch
+ */
+public interface LimitClause {
+
+	/**
+	 * Returns the {@code LIMIT} clause
+	 *
+	 * @param limit the actual limit to use.
+	 * @return rendered limit clause.
+	 */
+	String getClause(long limit);
+
+	/**
+	 * Returns the {@code LIMIT} clause
+	 *
+	 * @param limit the actual limit to use.
+	 * @param offset the offset to start from.
+	 * @return rendered limit clause.
+	 */
+	String getClause(long limit, long offset);
+
+	/**
+	 * Returns the {@link Position} where to apply the {@link #getClause(long) clause}.
+	 */
+	Position getClausePosition();
+
+	/**
+	 * Enumeration of where to render the clause within the SQL statement.
+	 */
+	enum Position {
+
+		/**
+		 * Append the clause at the end of the statement.
+		 */
+		END
+	}
+}