#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);
 }
 }