#64 - Migrate Select to StatementMapper.

Author: mp911de

src/main/java/org/springframework/data/r2dbc/function/DefaultDatabaseClient.java

@@ -60,7 +60,6 @@
 import org.springframework.data.r2dbc.function.query.Criteria;
 import org.springframework.data.r2dbc.function.query.Update;
 import org.springframework.data.r2dbc.support.R2dbcExceptionTranslator;
-import org.springframework.data.relational.core.sql.Select;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -749,20 +748,16 @@ public FetchSpec<Map<String, Object>> fetch() {
 
 		private <R> FetchSpec<R> exchange(BiFunction<Row, RowMetadata, R> mappingFunction) {
 
-			PreparedOperation<Select> operation = dataAccessStrategy.getStatements().select(this.table, this.projectedFields,
-					(t, configurer) -> {
-
-						configurer.withPageRequest(this.page).withSort(this.sort);
-
-						/*if (criteria != null) {
+			StatementMapper mapper = dataAccessStrategy.getStatementMapper();
 
-							BoundCondition boundCondition = dataAccessStrategy.createCriteriaUpdateMapper()
-									.getMappedCriteria(criteria, t);
-							configurer.withWhere(boundCondition.getCondition()).withBindings(boundCondition.getBindings());
-						} */
+			StatementMapper.SelectSpec selectSpec = mapper.createSelect(this.table).withProjection(this.projectedFields)
+					.withSort(this.sort).withPage(this.page);
 
-					});
+			if (this.criteria != null) {
+				selectSpec = selectSpec.withCriteria(this.criteria);
+			}
 
+			PreparedOperation<?> operation = mapper.getMappedObject(selectSpec);
 			return execute(operation, mappingFunction);
 		}
 
@@ -846,31 +841,22 @@ public FetchSpec<T> fetch() {
 		private <R> FetchSpec<R> exchange(BiFunction<Row, RowMetadata, R> mappingFunction) {
 
 			List<String> columns;
+			StatementMapper mapper = dataAccessStrategy.getStatementMapper().forType(this.typeToRead);
 
 			if (this.projectedFields.isEmpty()) {
 				columns = dataAccessStrategy.getAllColumns(this.typeToRead);
 			} else {
 				columns = this.projectedFields;
 			}
 
-			PreparedOperation<Select> operation = dataAccessStrategy.getStatements().select(this.table, columns,
-					(table, configurer) -> {
-
-						Sort sortToUse;
-						if (this.sort.isSorted()) {
-							sortToUse = dataAccessStrategy.getMappedSort(this.sort, this.typeToRead);
-						} else {
-							sortToUse = this.sort;
-						}
+			StatementMapper.SelectSpec selectSpec = mapper.createSelect(this.table).withProjection(columns)
+					.withPage(this.page).withSort(this.sort);
 
-						configurer.withPageRequest(this.page).withSort(sortToUse);
+			if (this.criteria != null) {
+				selectSpec = selectSpec.withCriteria(this.criteria);
+			}
 
-						/*if (criteria != null) {
-							BoundCondition boundCondition = dataAccessStrategy.createCriteriaUpdateMapper(this.typeToRead)
-									.getMappedCriteria(criteria, table);
-							configurer.withWhere(boundCondition.getCondition()).withBindings(boundCondition.getBindings());
-						} */
-					});
+			PreparedOperation<?> operation = mapper.getMappedObject(selectSpec);
 
 			return execute(operation, mappingFunction);
 		}

src/main/java/org/springframework/data/r2dbc/function/DefaultReactiveDataAccessStrategy.java

@@ -26,8 +26,6 @@
 
 import org.springframework.dao.InvalidDataAccessResourceUsageException;
 import org.springframework.data.convert.CustomConversions.StoreConversions;
-import org.springframework.data.domain.Sort;
-import org.springframework.data.domain.Sort.Order;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.r2dbc.dialect.ArrayColumns;
 import org.springframework.data.r2dbc.dialect.BindMarkersFactory;
@@ -62,7 +60,6 @@ public class DefaultReactiveDataAccessStrategy implements ReactiveDataAccessStra
 	private final R2dbcConverter converter;
 	private final UpdateMapper updateMapper;
 	private final MappingContext<RelationalPersistentEntity<?>, ? extends RelationalPersistentProperty> mappingContext;
-	private final StatementFactory statements;
 	private final StatementMapper statementMapper;
 
 	/**
@@ -127,11 +124,10 @@ public SelectRenderContext getSelect() {
 			}
 		};
 
-		this.statements = new DefaultStatementFactory(this.dialect, renderContext);
-		this.statementMapper = new DefaultStatementMapper(dialect, renderContext, updateMapper, mappingContext);
+		this.statementMapper = new DefaultStatementMapper(dialect, renderContext, this.updateMapper, this.mappingContext);
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy#getAllColumns(java.lang.Class)
 	 */
@@ -152,7 +148,7 @@ public List<String> getAllColumns(Class<?> entityType) {
 		return columnNames;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy#getIdentifierColumns(java.lang.Class)
 	 */
@@ -182,7 +178,7 @@ public OutboundRow getOutboundRow(Object object) {
 
 		OutboundRow row = new OutboundRow();
 
-		converter.write(object, row);
+		this.converter.write(object, row);
 
 		RelationalPersistentEntity<?> entity = getRequiredPersistentEntity(ClassUtils.getUserClass(object));
 
@@ -205,53 +201,25 @@ private boolean shouldConvertArrayValue(RelationalPersistentProperty property, S
 
 	private SettableValue getArrayValue(SettableValue value, RelationalPersistentProperty property) {
 
-		ArrayColumns arrayColumns = dialect.getArraySupport();
+		ArrayColumns arrayColumns = this.dialect.getArraySupport();
 
 		if (!arrayColumns.isSupported()) {
 
 			throw new InvalidDataAccessResourceUsageException(
-					"Dialect " + dialect.getClass().getName() + " does not support array columns");
+					"Dialect " + this.dialect.getClass().getName() + " does not support array columns");
 		}
 
-		return SettableValue.fromOrEmpty(converter.getArrayValue(arrayColumns, property, value.getValue()),
+		return SettableValue.fromOrEmpty(this.converter.getArrayValue(arrayColumns, property, value.getValue()),
 				property.getActualType());
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy#getMappedSort(java.lang.Class, org.springframework.data.domain.Sort)
-	 */
-	@Override
-	public Sort getMappedSort(Sort sort, Class<?> typeToRead) {
-
-		RelationalPersistentEntity<?> entity = getPersistentEntity(typeToRead);
-		if (entity == null) {
-			return sort;
-		}
-
-		List<Order> mappedOrder = new ArrayList<>();
-
-		for (Order order : sort) {
-
-			RelationalPersistentProperty persistentProperty = entity.getPersistentProperty(order.getProperty());
-			if (persistentProperty == null) {
-				mappedOrder.add(order);
-			} else {
-				mappedOrder
-						.add(Order.by(persistentProperty.getColumnName()).with(order.getNullHandling()).with(order.getDirection()));
-			}
-		}
-
-		return Sort.by(mappedOrder);
-	}
-
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy#getRowMapper(java.lang.Class)
 	 */
 	@Override
 	public <T> BiFunction<Row, RowMetadata, T> getRowMapper(Class<T> typeToRead) {
-		return new EntityRowMapper<>(typeToRead, converter);
+		return new EntityRowMapper<>(typeToRead, this.converter);
 	}
 
 	/*
@@ -265,13 +233,8 @@ public String getTableName(Class<?> type) {
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy#getStatements()
+	 * @see org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy#getStatementMapper()
 	 */
-	@Override
-	public StatementFactory getStatements() {
-		return this.statements;
-	}
-
 	@Override
 	public StatementMapper getStatementMapper() {
 		return this.statementMapper;
@@ -283,27 +246,27 @@ public StatementMapper getStatementMapper() {
 	 */
 	@Override
 	public BindMarkersFactory getBindMarkersFactory() {
-		return dialect.getBindMarkersFactory();
+		return this.dialect.getBindMarkersFactory();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.r2dbc.function.ReactiveDataAccessStrategy#getConverter()
 	 */
 	public R2dbcConverter getConverter() {
-		return converter;
+		return this.converter;
 	}
 
 	public MappingContext<RelationalPersistentEntity<?>, ? extends RelationalPersistentProperty> getMappingContext() {
-		return mappingContext;
+		return this.mappingContext;
 	}
 
 	private RelationalPersistentEntity<?> getRequiredPersistentEntity(Class<?> typeToRead) {
-		return mappingContext.getRequiredPersistentEntity(typeToRead);
+		return this.mappingContext.getRequiredPersistentEntity(typeToRead);
 	}
 
 	@Nullable
 	private RelationalPersistentEntity<?> getPersistentEntity(Class<?> typeToRead) {
-		return mappingContext.getPersistentEntity(typeToRead);
+		return this.mappingContext.getPersistentEntity(typeToRead);
 	}
 }