#30 - Add custom conversion support.

We now support custom conversions via R2dbcCustomConversions.
Custom conversions introduces simple types that depend on the used dialect.
Custom conversions and simple types are held in RelationalConverter and MappingContext.

Simple types and conversions are used by DatabaseClient and repository support to properly apply registered converters and support native types such as array-columns.

Related tickets: #22, #26.
Original pull request: #31.

Author: mp911de

src/main/java/org/springframework/data/r2dbc/config/AbstractR2dbcConfiguration.java

@@ -17,15 +17,20 @@
 
 import io.r2dbc.spi.ConnectionFactory;
 
+import java.util.Collections;
 import java.util.Optional;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.convert.CustomConversions;
+import org.springframework.data.convert.CustomConversions.StoreConversions;
 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;
+import org.springframework.data.r2dbc.function.convert.R2dbcCustomConversions;
 import org.springframework.data.r2dbc.support.R2dbcExceptionTranslator;
 import org.springframework.data.r2dbc.support.SqlErrorCodeR2dbcExceptionTranslator;
 import org.springframework.data.relational.core.conversion.BasicRelationalConverter;
@@ -95,33 +100,59 @@ public DatabaseClient databaseClient(ReactiveDataAccessStrategy dataAccessStrate
 	 * Register a {@link RelationalMappingContext} and apply an optional {@link NamingStrategy}.
 	 *
 	 * @param namingStrategy optional {@link NamingStrategy}. Use {@link NamingStrategy#INSTANCE} as fallback.
+	 * @param r2dbcCustomConversions customized R2DBC conversions.
 	 * @return must not be {@literal null}.
 	 * @throws IllegalArgumentException if any of the required args is {@literal null}.
 	 */
 	@Bean
-	public RelationalMappingContext r2dbcMappingContext(Optional<NamingStrategy> namingStrategy) {
+	public RelationalMappingContext r2dbcMappingContext(Optional<NamingStrategy> namingStrategy,
+			R2dbcCustomConversions r2dbcCustomConversions) {
 
 		Assert.notNull(namingStrategy, "NamingStrategy must not be null!");
 
-		return new RelationalMappingContext(namingStrategy.orElse(NamingStrategy.INSTANCE));
+		RelationalMappingContext relationalMappingContext = new RelationalMappingContext(
+				namingStrategy.orElse(NamingStrategy.INSTANCE));
+		relationalMappingContext.setSimpleTypeHolder(r2dbcCustomConversions.getSimpleTypeHolder());
+
+		return relationalMappingContext;
 	}
 
 	/**
 	 * Creates a {@link ReactiveDataAccessStrategy} using the configured {@link #r2dbcMappingContext(Optional)
 	 * RelationalMappingContext}.
 	 *
 	 * @param mappingContext the configured {@link RelationalMappingContext}.
+	 * @param r2dbcCustomConversions customized R2DBC conversions.
 	 * @return must not be {@literal null}.
-	 * @see #r2dbcMappingContext(Optional)
+	 * @see #r2dbcMappingContext(Optional, R2dbcCustomConversions)
 	 * @see #getDialect(ConnectionFactory)
 	 * @throws IllegalArgumentException if any of the {@literal mappingContext} is {@literal null}.
 	 */
 	@Bean
-	public ReactiveDataAccessStrategy reactiveDataAccessStrategy(RelationalMappingContext mappingContext) {
+	public ReactiveDataAccessStrategy reactiveDataAccessStrategy(RelationalMappingContext mappingContext,
+			R2dbcCustomConversions r2dbcCustomConversions) {
 
 		Assert.notNull(mappingContext, "MappingContext must not be null!");
-		return new DefaultReactiveDataAccessStrategy(getDialect(connectionFactory()),
-				new BasicRelationalConverter(mappingContext));
+
+		BasicRelationalConverter converter = new BasicRelationalConverter(mappingContext, r2dbcCustomConversions);
+
+		return new DefaultReactiveDataAccessStrategy(getDialect(connectionFactory()), converter);
+	}
+
+	/**
+	 * Register custom {@link Converter}s in a {@link CustomConversions} object if required. These
+	 * {@link CustomConversions} will be registered with the {@link BasicRelationalConverter} and
+	 * {@link #r2dbcMappingContext(Optional, R2dbcCustomConversions)}. Returns an empty {@link R2dbcCustomConversions}
+	 * instance by default.
+	 *
+	 * @return must not be {@literal null}.
+	 */
+	@Bean
+	public R2dbcCustomConversions r2dbcCustomConversions() {
+
+		Dialect dialect = getDialect(connectionFactory());
+		StoreConversions storeConversions = StoreConversions.of(dialect.getSimpleTypeHolder());
+		return new R2dbcCustomConversions(storeConversions, Collections.emptyList());
 	}
 
 	/**

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

@@ -1,5 +1,11 @@
 package org.springframework.data.r2dbc.dialect;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+
+import org.springframework.data.mapping.model.SimpleTypeHolder;
+
 /**
  * Represents a dialect that is implemented by a particular database.
  *
@@ -26,10 +32,41 @@ public interface Dialect {
 	@Deprecated
 	String generatedKeysClause();
 
+	/**
+	 * Return a collection of types that are natively supported by this database/driver. Defaults to
+	 * {@link Collections#emptySet()}.
+	 *
+	 * @return a collection of types that are natively supported by this database/driver. Defaults to
+	 *         {@link Collections#emptySet()}.
+	 */
+	default Collection<? extends Class<?>> getSimpleTypes() {
+		return Collections.emptySet();
+	}
+
+	/**
+	 * Return the {@link SimpleTypeHolder} for this dialect.
+	 *
+	 * @return the {@link SimpleTypeHolder} for this dialect.
+	 * @see #getSimpleTypes()
+	 */
+	default SimpleTypeHolder getSimpleTypeHolder() {
+		return new SimpleTypeHolder(new HashSet<>(getSimpleTypes()), true);
+	}
+
 	/**
 	 * Return the {@link LimitClause} used by this dialect.
 	 *
 	 * @return the {@link LimitClause} used by this dialect.
 	 */
 	LimitClause limit();
+
+	/**
+	 * Returns {@literal true} whether this dialect supports array-typed column. Collection-typed columns can map their
+	 * content to native array types.
+	 *
+	 * @return {@literal true} whether this dialect supports array-typed columns.
+	 */
+	default boolean supportsArrayColumns() {
+		return false;
+	}
 }

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

@@ -1,12 +1,25 @@
 package org.springframework.data.r2dbc.dialect;
 
+import java.net.InetAddress;
+import java.net.URI;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
 /**
  * An SQL dialect for Postgres.
  *
  * @author Mark Paluch
  */
 public class PostgresDialect implements Dialect {
 
+	private static final Set<Class<?>> SIMPLE_TYPES = new HashSet<>(
+			Arrays.asList(List.class, Collection.class, String[].class, UUID.class, URL.class, URI.class, InetAddress.class));
+
 	/**
 	 * Singleton instance.
 	 */
@@ -62,6 +75,15 @@ public String generatedKeysClause() {
 		return "RETURNING *";
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.r2dbc.dialect.Dialect#getSimpleTypesKeys()
+	 */
+	@Override
+	public Collection<? extends Class<?>> getSimpleTypes() {
+		return SIMPLE_TYPES;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.dialect.Dialect#limit()
@@ -70,4 +92,13 @@ public String generatedKeysClause() {
 	public LimitClause limit() {
 		return LIMIT_CLAUSE;
 	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.r2dbc.dialect.Dialect#supportsArrayColumns()
+	 */
+	@Override
+	public boolean supportsArrayColumns() {
+		return true;
+	}
 }

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

@@ -1,12 +1,20 @@
 package org.springframework.data.r2dbc.dialect;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
 /**
  * An SQL dialect for Microsoft SQL Server.
  *
  * @author Mark Paluch
  */
 public class SqlServerDialect implements Dialect {
 
+	private static final Set<Class<?>> SIMPLE_TYPES = new HashSet<>(Collections.singletonList(UUID.class));
+
 	/**
 	 * Singleton instance.
 	 */
@@ -63,6 +71,15 @@ public String generatedKeysClause() {
 		return "select SCOPE_IDENTITY() AS GENERATED_KEYS";
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.r2dbc.dialect.Dialect#getSimpleTypesKeys()
+	 */
+	@Override
+	public Collection<? extends Class<?>> getSimpleTypes() {
+		return SIMPLE_TYPES;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.dialect.Dialect#limit()