#85 - Consider BigDecimal and BigInteger as simple types.

We now consider BigDecimal and BigInteger as simple types and no longer as entities.

We also no longer set properties whose value is null.

Author: mp911de

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

@@ -17,6 +17,8 @@
 
 import io.r2dbc.spi.Row;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
@@ -36,7 +38,7 @@ public class R2dbcSimpleTypeHolder extends SimpleTypeHolder {
 	 * Set of R2DBC simple types.
 	 */
 	public static final Set<Class<?>> R2DBC_SIMPLE_TYPES = Collections
-			.unmodifiableSet(new HashSet<>(Arrays.asList(OutboundRow.class, Row.class)));
+			.unmodifiableSet(new HashSet<>(Arrays.asList(OutboundRow.class, Row.class, BigInteger.class, BigDecimal.class)));
 
 	public static final SimpleTypeHolder HOLDER = new R2dbcSimpleTypeHolder();
 

src/main/java/org/springframework/data/r2dbc/function/convert/MappingR2dbcConverter.java

@@ -114,7 +114,11 @@ private <R> R read(RelationalPersistentEntity<R> entity, Row row) {
 				continue;
 			}
 
-			propertyAccessor.setProperty(property, readFrom(row, property, ""));
+			Object value = readFrom(row, property, "");
+
+			if (value != null) {
+				propertyAccessor.setProperty(property, value);
+			}
 		}
 
 		return result;
@@ -266,8 +270,7 @@ private void writeSimpleInternal(OutboundRow sink, Object value, RelationalPersi
 
 	private void writeNullInternal(OutboundRow sink, RelationalPersistentProperty property) {
 
-		sink.put(property.getColumnName(),
-				SettableValue.empty(getPotentiallyConvertedSimpleNullType(property.getType())));
+		sink.put(property.getColumnName(), SettableValue.empty(getPotentiallyConvertedSimpleNullType(property.getType())));
 	}
 
 	private Class<?> getPotentiallyConvertedSimpleNullType(Class<?> type) {
@@ -419,7 +422,14 @@ public <T> T getParameterValue(Parameter<T, RelationalPersistentProperty> parame
 			String column = prefix + property.getColumnName();
 
 			try {
-				return converter.getConversionService().convert(resultSet.get(column), parameter.getType().getType());
+
+				Object value = resultSet.get(column);
+
+				if (value == null) {
+					return null;
+				}
+
+				return converter.getConversionService().convert(value, parameter.getType().getType());
 			} catch (Exception o_O) {
 				throw new MappingException(String.format("Couldn't read column %s from Row.", column), o_O);
 			}

src/main/java/org/springframework/data/r2dbc/function/convert/R2dbcConverters.java

@@ -30,6 +30,12 @@
 
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.ConverterFactory;
+import org.springframework.data.convert.CustomConversions;
+import org.springframework.data.convert.Jsr310Converters;
+import org.springframework.data.convert.WritingConverter;
+import org.springframework.data.r2dbc.function.convert.R2dbcConverters.RowToNumberConverterFactory.LocalDateConverterOverride;
+import org.springframework.data.r2dbc.function.convert.R2dbcConverters.RowToNumberConverterFactory.LocalDateTimeConverterOverride;
+import org.springframework.data.r2dbc.function.convert.R2dbcConverters.RowToNumberConverterFactory.LocalTimeConverterOverride;
 import org.springframework.data.r2dbc.function.convert.R2dbcConverters.RowToNumberConverterFactory.RowToOffsetDateTimeConverter;
 import org.springframework.data.r2dbc.function.convert.R2dbcConverters.RowToNumberConverterFactory.RowToStringConverter;
 import org.springframework.data.r2dbc.function.convert.R2dbcConverters.RowToNumberConverterFactory.RowToUuidConverter;
@@ -67,6 +73,22 @@ public static Collection<Object> getConvertersToRegister() {
 		return converters;
 	}
 
+	/**
+	 * @return A list of the registered converters to enforce JSR-310 type usage.
+	 * @see CustomConversions#DEFAULT_CONVERTERS
+	 * @see Jsr310Converters
+	 */
+	public static Collection<Object> getOverrideConvertersToRegister() {
+
+		List<Object> converters = new ArrayList<>();
+
+		converters.add(LocalDateConverterOverride.INSTANCE);
+		converters.add(LocalDateTimeConverterOverride.INSTANCE);
+		converters.add(LocalTimeConverterOverride.INSTANCE);
+
+		return converters;
+	}
+
 	/**
 	 * Simple singleton to convert {@link Row}s to their {@link Boolean} representation.
 	 *
@@ -229,5 +251,53 @@ public ZonedDateTime convert(Row row) {
 				return row.get(0, ZonedDateTime.class);
 			}
 		}
+
+		/**
+		 * {@link Converter} override that forces {@link LocalDate} to stay on {@link LocalDate}.
+		 *
+		 * @author Mark Paluch
+		 */
+		@WritingConverter
+		public enum LocalDateConverterOverride implements Converter<LocalDate, LocalDate> {
+
+			INSTANCE;
+
+			@Override
+			public LocalDate convert(LocalDate value) {
+				return value;
+			}
+		}
+
+		/**
+		 * {@link Converter} override that forces {@link LocalDateTime} to stay on {@link LocalDateTime}.
+		 *
+		 * @author Mark Paluch
+		 */
+		@WritingConverter
+		public enum LocalDateTimeConverterOverride implements Converter<LocalDateTime, LocalDateTime> {
+
+			INSTANCE;
+
+			@Override
+			public LocalDateTime convert(LocalDateTime value) {
+				return value;
+			}
+		}
+
+		/**
+		 * {@link Converter} override that forces {@link LocalTime} to stay on {@link LocalTime}.
+		 *
+		 * @author Mark Paluch
+		 */
+		@WritingConverter
+		public enum LocalTimeConverterOverride implements Converter<LocalTime, LocalTime> {
+
+			INSTANCE;
+
+			@Override
+			public LocalTime convert(LocalTime value) {
+				return value;
+			}
+		}
 	}
 }

src/main/java/org/springframework/data/r2dbc/function/convert/R2dbcCustomConversions.java

@@ -40,7 +40,7 @@ public class R2dbcCustomConversions extends CustomConversions {
 	 * @param converters must not be {@literal null}.
 	 */
 	public R2dbcCustomConversions(Collection<?> converters) {
-		super(STORE_CONVERSIONS, converters);
+		super(STORE_CONVERSIONS, appendOverriddes(converters));
 	}
 
 	/**
@@ -50,6 +50,14 @@ public R2dbcCustomConversions(Collection<?> converters) {
 	 * @param converters must not be {@literal null}.
 	 */
 	public R2dbcCustomConversions(StoreConversions storeConversions, Collection<?> converters) {
-		super(storeConversions, converters);
+		super(storeConversions, appendOverriddes(converters));
+	}
+
+	private static Collection<?> appendOverriddes(Collection<?> converters) {
+
+		List<Object> objects = new ArrayList<>(converters);
+		objects.addAll(R2dbcConverters.getOverrideConvertersToRegister());
+
+		return objects;
 	}
 }

src/test/java/org/springframework/data/r2dbc/function/PostgresReactiveDataAccessStrategyTests.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.r2dbc.function;
+
+import org.springframework.data.r2dbc.dialect.PostgresDialect;
+
+/**
+ * {@link PostgresDialect} specific tests for {@link ReactiveDataAccessStrategy}.
+ *
+ * @author Mark Paluch
+ */
+public class PostgresReactiveDataAccessStrategyTests extends ReactiveDataAccessStrategyTestSupport {
+
+	private final ReactiveDataAccessStrategy strategy = new DefaultReactiveDataAccessStrategy(PostgresDialect.INSTANCE);
+
+	@Override
+	protected ReactiveDataAccessStrategy getStrategy() {
+		return strategy;
+	}
+}