#260 - Support interface projections with DatabaseClient.as(…).

We now support interface projections when using as(Class) through ProjectionFactory. Simple, type-less queries (execute, select from table) are backed by Map implementations and require the projection type to return a similar type than the expected value. Simple types (such as numeric types) are converted between the backing result and the projection. Conversion of complex types requires a source with type information such as a typed select (select().from(Person.class).as(PersonProjection.class)) to apply registered converters on property-level.

Author: mp911de

Diff for: src/main/asciidoc/reference/r2dbc-fluent.adoc

@@ -40,14 +40,18 @@ Mono<Person> first = databaseClient.select()
 <1> Selecting from a table by name returns row results as `Map<String, Object>` with case-insensitive column name matching.
 <2> The issued query declares a `WHERE` condition on `firstname` and `lastname` columns to filter results.
 <3> Results can be ordered by individual column names, resulting in an `ORDER BY` clause.
-<4> Selecting the one result fetches only a single row. This way of consuming rows expects the query to return exactly a single result.
+<4> Selecting the one result fetches only a single row.
+This way of consuming rows expects the query to return exactly a single result.
 `Mono` emits a `IncorrectResultSizeDataAccessException` if the query yields more than a single result.
 ====
 
+TIP: You can directly apply <<projections,Projections>> to result documents by providing the target type via `as(Class<?>)`.
+
 You can consume Query results in three ways:
 
 * Through object mapping (for example, `as(Class<T>)`) by using Spring Data's mapping-metadata.
-* As `Map<String, Object>` where column names are mapped to their value. Column names are looked up in a case-insensitive way.
+* As `Map<String, Object>` where column names are mapped to their value.
+Column names are looked up in a case-insensitive way.
 * By supplying a mapping `BiFunction` for direct access to R2DBC `Row` and `RowMetadata`.
 
 You can switch between retrieving a single entity and retrieving multiple entities through the following terminating methods:

Diff for: src/main/java/org/springframework/data/r2dbc/config/AbstractR2dbcConfiguration.java

@@ -30,6 +30,7 @@
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.convert.CustomConversions.StoreConversions;
+import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
 import org.springframework.data.r2dbc.convert.MappingR2dbcConverter;
 import org.springframework.data.r2dbc.convert.R2dbcCustomConversions;
 import org.springframework.data.r2dbc.core.DatabaseClient;
@@ -106,10 +107,17 @@ public DatabaseClient databaseClient(ReactiveDataAccessStrategy dataAccessStrate
 		Assert.notNull(dataAccessStrategy, "DataAccessStrategy must not be null!");
 		Assert.notNull(exceptionTranslator, "ExceptionTranslator must not be null!");
 
+		SpelAwareProxyProjectionFactory projectionFactory = new SpelAwareProxyProjectionFactory();
+		if (context != null) {
+			projectionFactory.setBeanFactory(context);
+			projectionFactory.setBeanClassLoader(context.getClassLoader());
+		}
+
 		return DatabaseClient.builder() //
 				.connectionFactory(lookupConnectionFactory()) //
 				.dataAccessStrategy(dataAccessStrategy) //
 				.exceptionTranslator(exceptionTranslator) //
+				.projectionFactory(projectionFactory) //
 				.build();
 	}
 

Diff for: src/main/java/org/springframework/data/r2dbc/core/DatabaseClient.java

@@ -30,6 +30,7 @@
 
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.r2dbc.mapping.SettableValue;
 import org.springframework.data.r2dbc.query.Criteria;
 import org.springframework.data.r2dbc.query.Update;
@@ -157,6 +158,15 @@ interface Builder {
 		 */
 		Builder namedParameters(boolean enabled);
 
+		/**
+		 * Configures the {@link org.springframework.data.projection.ProjectionFactory projection factory}.
+		 *
+		 * @param factory must not be {@literal null}.
+		 * @return {@code this} {@link Builder}.
+		 * @since 1.1
+		 */
+		Builder projectionFactory(ProjectionFactory factory);
+
 		/**
 		 * Configures a {@link Consumer} to configure this builder.
 		 *

Diff for: src/main/java/org/springframework/data/r2dbc/core/DefaultDatabaseClient.java

@@ -49,6 +49,7 @@
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.r2dbc.UncategorizedR2dbcException;
 import org.springframework.data.r2dbc.connectionfactory.ConnectionFactoryUtils;
 import org.springframework.data.r2dbc.connectionfactory.ConnectionProxy;
@@ -82,13 +83,17 @@ class DefaultDatabaseClient implements DatabaseClient, ConnectionAccessor {
 
 	private final DefaultDatabaseClientBuilder builder;
 
+	private final ProjectionFactory projectionFactory;
+
 	DefaultDatabaseClient(ConnectionFactory connector, R2dbcExceptionTranslator exceptionTranslator,
-			ReactiveDataAccessStrategy dataAccessStrategy, boolean namedParameters, DefaultDatabaseClientBuilder builder) {
+			ReactiveDataAccessStrategy dataAccessStrategy, boolean namedParameters, ProjectionFactory projectionFactory,
+			DefaultDatabaseClientBuilder builder) {
 
 		this.connector = connector;
 		this.exceptionTranslator = exceptionTranslator;
 		this.dataAccessStrategy = dataAccessStrategy;
 		this.namedParameters = namedParameters;
+		this.projectionFactory = projectionFactory;
 		this.builder = builder;
 	}
 
@@ -544,7 +549,7 @@ protected ExecuteSpecSupport createInstance(Map<Integer, SettableValue> byIndex,
 	@SuppressWarnings("unchecked")
 	protected class DefaultTypedExecuteSpec<T> extends ExecuteSpecSupport implements TypedExecuteSpec<T> {
 
-		private final Class<T> typeToRead;
+		private final @Nullable Class<T> typeToRead;
 		private final BiFunction<Row, RowMetadata, T> mappingFunction;
 
 		DefaultTypedExecuteSpec(Map<Integer, SettableValue> byIndex, Map<String, SettableValue> byName,
@@ -553,7 +558,13 @@ protected class DefaultTypedExecuteSpec<T> extends ExecuteSpecSupport implements
 			super(byIndex, byName, sqlSupplier);
 
 			this.typeToRead = typeToRead;
-			this.mappingFunction = dataAccessStrategy.getRowMapper(typeToRead);
+
+			if (typeToRead.isInterface()) {
+				this.mappingFunction = ColumnMapRowMapper.INSTANCE
+						.andThen(map -> projectionFactory.createProjection(typeToRead, map));
+			} else {
+				this.mappingFunction = dataAccessStrategy.getRowMapper(typeToRead);
+			}
 		}
 
 		DefaultTypedExecuteSpec(Map<Integer, SettableValue> byIndex, Map<String, SettableValue> byName,
@@ -638,6 +649,9 @@ public GenericSelectSpec from(String table) {
 
 		@Override
 		public <T> TypedSelectSpec<T> from(Class<T> table) {
+
+			assertRegularClass(table);
+
 			return new DefaultTypedSelectSpec<>(table);
 		}
 	}
@@ -735,8 +749,16 @@ public <R> TypedSelectSpec<R> as(Class<R> resultType) {
 
 			Assert.notNull(resultType, "Result type must not be null!");
 
+			BiFunction<Row, RowMetadata, R> rowMapper;
+
+			if (resultType.isInterface()) {
+				rowMapper = ColumnMapRowMapper.INSTANCE.andThen(map -> projectionFactory.createProjection(resultType, map));
+			} else {
+				rowMapper = dataAccessStrategy.getRowMapper(resultType);
+			}
+
 			return new DefaultTypedSelectSpec<>(this.table, this.projectedFields, this.criteria, this.sort, this.page,
-					resultType, dataAccessStrategy.getRowMapper(resultType));
+					resultType, rowMapper);
 		}
 
 		@Override
@@ -808,10 +830,10 @@ protected DefaultGenericSelectSpec createInstance(String table, List<String> pro
 	@SuppressWarnings("unchecked")
 	private class DefaultTypedSelectSpec<T> extends DefaultSelectSpecSupport implements TypedSelectSpec<T> {
 
-		private final @Nullable Class<T> typeToRead;
+		private final Class<T> typeToRead;
 		private final BiFunction<Row, RowMetadata, T> mappingFunction;
 
-		DefaultTypedSelectSpec(@Nullable Class<T> typeToRead) {
+		DefaultTypedSelectSpec(Class<T> typeToRead) {
 
 			super(dataAccessStrategy.getTableName(typeToRead));
 
@@ -833,7 +855,16 @@ public <R> FetchSpec<R> as(Class<R> resultType) {
 
 			Assert.notNull(resultType, "Result type must not be null!");
 
-			return exchange(dataAccessStrategy.getRowMapper(resultType));
+			BiFunction<Row, RowMetadata, R> rowMapper;
+
+			if (resultType.isInterface()) {
+				rowMapper = dataAccessStrategy.getRowMapper(typeToRead)
+						.andThen(r -> projectionFactory.createProjection(resultType, r));
+			} else {
+				rowMapper = dataAccessStrategy.getRowMapper(resultType);
+			}
+
+			return exchange(rowMapper);
 		}
 
 		@Override
@@ -920,6 +951,9 @@ public GenericInsertSpec<Map<String, Object>> into(String table) {
 
 		@Override
 		public <T> TypedInsertSpec<T> into(Class<T> table) {
+
+			assertRegularClass(table);
+
 			return new DefaultTypedInsertSpec<>(table, ColumnMapRowMapper.INSTANCE);
 		}
 	}
@@ -1136,6 +1170,9 @@ public GenericUpdateSpec table(String table) {
 
 		@Override
 		public <T> TypedUpdateSpec<T> table(Class<T> table) {
+
+			assertRegularClass(table);
+
 			return new DefaultTypedUpdateSpec<>(table, null, null);
 		}
 	}
@@ -1297,6 +1334,9 @@ public DefaultDeleteSpec<?> from(String table) {
 
 		@Override
 		public <T> DefaultDeleteSpec<T> from(Class<T> table) {
+
+			assertRegularClass(table);
+
 			return new DefaultDeleteSpec<>(table, null, null);
 		}
 	}
@@ -1477,6 +1517,13 @@ private static String getRequiredSql(Supplier<String> sqlSupplier) {
 		return sql;
 	}
 
+	private static void assertRegularClass(Class<?> table) {
+
+		Assert.notNull(table, "Entity type must not be null");
+		Assert.isTrue(!table.isInterface() && !table.isEnum(),
+				() -> String.format("Entity type %s must be a class", table.getName()));
+	}
+
 	/**
 	 * Invocation handler that suppresses close calls on R2DBC Connections. Also prepares returned Statement
 	 * (Prepared/CallbackStatement) objects.

Diff for: src/main/java/org/springframework/data/r2dbc/core/DefaultDatabaseClientBuilder.java

@@ -20,6 +20,7 @@
 
 import java.util.function.Consumer;
 
+import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.r2dbc.core.DatabaseClient.Builder;
 import org.springframework.data.r2dbc.dialect.DialectResolver;
 import org.springframework.data.r2dbc.dialect.R2dbcDialect;
@@ -43,6 +44,8 @@ class DefaultDatabaseClientBuilder implements DatabaseClient.Builder {
 
 	private boolean namedParameters = true;
 
+	private ProjectionFactory projectionFactory;
+
 	DefaultDatabaseClientBuilder() {}
 
 	DefaultDatabaseClientBuilder(DefaultDatabaseClientBuilder other) {
@@ -53,6 +56,7 @@ class DefaultDatabaseClientBuilder implements DatabaseClient.Builder {
 		this.exceptionTranslator = other.exceptionTranslator;
 		this.accessStrategy = other.accessStrategy;
 		this.namedParameters = other.namedParameters;
+		this.projectionFactory = other.projectionFactory;
 	}
 
 	/*
@@ -105,6 +109,19 @@ public Builder namedParameters(boolean enabled) {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.r2dbc.function.DatabaseClient.Builder#projectionFactory(ProjectionFactory)
+	 */
+	@Override
+	public Builder projectionFactory(ProjectionFactory factory) {
+
+		Assert.notNull(factory, "ProjectionFactory must not be null!");
+
+		this.projectionFactory = factory;
+		return this;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.function.DatabaseClient.Builder#build()
@@ -126,13 +143,8 @@ public DatabaseClient build() {
 			accessStrategy = new DefaultReactiveDataAccessStrategy(dialect);
 		}
 
-		return doBuild(this.connectionFactory, exceptionTranslator, accessStrategy, namedParameters,
-				new DefaultDatabaseClientBuilder(this));
-	}
-
-	protected DatabaseClient doBuild(ConnectionFactory connector, R2dbcExceptionTranslator exceptionTranslator,
-			ReactiveDataAccessStrategy accessStrategy, boolean namedParameters, DefaultDatabaseClientBuilder builder) {
-		return new DefaultDatabaseClient(connector, exceptionTranslator, accessStrategy, namedParameters, builder);
+		return new DefaultDatabaseClient(this.connectionFactory, exceptionTranslator, accessStrategy, namedParameters,
+				projectionFactory, new DefaultDatabaseClientBuilder(this));
 	}
 
 	/*