Do not convert from LocalDateTime to Timestamp by default.

Most supported databases don't need that conversion.

Db2 does need it and gets it through JdbcDb2Dialect.

As part of the effort it became obvious that the filtering for conversions between Date and JSR310 data types was broken.
It is fixed now, which required a dedicated reading conversion from LocalDateTime to Date for JdbcMySqlDialect.

Closes #974

Author: schauder

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/JdbcColumnTypes.java

@@ -16,6 +16,7 @@
 package org.springframework.data.jdbc.core.convert;
 
 import java.sql.Timestamp;
+import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
 import java.time.ZonedDateTime;
 import java.time.temporal.Temporal;
@@ -54,6 +55,7 @@ public Class<?> resolvePrimitiveType(Class<?> type) {
 		javaToDbType.put(Enum.class, String.class);
 		javaToDbType.put(ZonedDateTime.class, String.class);
 		javaToDbType.put(OffsetDateTime.class, OffsetDateTime.class);
+		javaToDbType.put(LocalDateTime.class, LocalDateTime.class);
 		javaToDbType.put(Temporal.class, Timestamp.class);
 	}
 

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/JdbcCustomConversions.java

@@ -15,12 +15,12 @@
  */
 package org.springframework.data.jdbc.core.convert;
 
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Predicate;
 
+import org.springframework.core.convert.converter.GenericConverter;
 import org.springframework.core.convert.converter.GenericConverter.ConvertiblePair;
 import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.jdbc.core.mapping.JdbcSimpleTypes;
@@ -38,10 +38,13 @@
  */
 public class JdbcCustomConversions extends CustomConversions {
 
-	private static final Collection<Object> STORE_CONVERTERS = Collections.unmodifiableCollection(Jsr310TimestampBasedConverters.getConvertersToRegister());
+	private static final Collection<Object> STORE_CONVERTERS = Collections
+			.unmodifiableCollection(Jsr310TimestampBasedConverters.getConvertersToRegister());
 	private static final StoreConversions STORE_CONVERSIONS = StoreConversions.of(JdbcSimpleTypes.HOLDER,
 			STORE_CONVERTERS);
 
+	private static final Predicate<ConvertiblePair> excludeConversionsBetweenDateAndJsr310Types= cp -> !isDateTimeApiConversion(cp);
+
 	/**
 	 * Creates an empty {@link JdbcCustomConversions} object.
 	 */
@@ -50,21 +53,23 @@ public JdbcCustomConversions() {
 	}
 
 	/**
-	 * Create a new {@link JdbcCustomConversions} instance registering the given converters and the default store converters.
+	 * Create a new {@link JdbcCustomConversions} instance registering the given converters and the default store
+	 * converters.
 	 *
 	 * @param converters must not be {@literal null}.
 	 */
 	public JdbcCustomConversions(List<?> converters) {
-		super(new ConverterConfiguration(STORE_CONVERSIONS, converters, JdbcCustomConversions::isDateTimeApiConversion));
+		super(new ConverterConfiguration(STORE_CONVERSIONS, converters, excludeConversionsBetweenDateAndJsr310Types));
 	}
 
 	/**
-	 * Create a new {@link JdbcCustomConversions} instance registering the given converters and the default store converters.
+	 * Create a new {@link JdbcCustomConversions} instance registering the given converters and the default store
+	 * converters.
 	 *
 	 * @since 2.3
 	 */
 	public JdbcCustomConversions(StoreConversions storeConversions, List<?> userConverters) {
-		super(new ConverterConfiguration(storeConversions, userConverters, JdbcCustomConversions::isDateTimeApiConversion));
+		super(new ConverterConfiguration(storeConversions, userConverters, cp -> !isDateTimeApiConversion(cp)));
 	}
 
 	/**
@@ -98,6 +103,6 @@ private static boolean isDateTimeApiConversion(ConvertiblePair cp) {
 			return cp.getSourceType().getTypeName().startsWith("java.time.");
 		}
 
-		return true;
+		return false;
 	}
 }

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/Jsr310TimestampBasedConverters.java

@@ -45,22 +45,21 @@
  * @author Jens Schauder
  * @since 2.2
  */
-abstract class Jsr310TimestampBasedConverters {
-
-	private static final List<Class<?>> CLASSES = Arrays.asList(LocalDateTime.class, LocalDate.class, LocalTime.class,
-			Instant.class, ZoneId.class, Duration.class, Period.class);
+public abstract class Jsr310TimestampBasedConverters {
 
 	/**
-	 * Returns the converters to be registered. Will only return converters in case we're running on Java 8.
+	 * Returns the converters to be registered.
+	 *
+	 * Note that the {@link LocalDateTimeToTimestampConverter} is not included, since many database don't need that conversion.
+	 * Databases that do need it, should include it in the conversions offered by their respective dialect.
 	 *
-	 * @return
+	 * @return a collection of converters. Guaranteed to be not {@literal null}.
 	 */
 	public static Collection<Converter<?, ?>> getConvertersToRegister() {
 
 		List<Converter<?, ?>> converters = new ArrayList<>(8);
 
 		converters.add(TimestampToLocalDateTimeConverter.INSTANCE);
-		converters.add(LocalDateTimeToTimestampConverter.INSTANCE);
 		converters.add(TimestampToLocalDateConverter.INSTANCE);
 		converters.add(LocalDateToTimestampConverter.INSTANCE);
 		converters.add(TimestampToLocalTimeConverter.INSTANCE);

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/dialect/JdbcDb2Dialect.java

@@ -23,6 +23,7 @@
 
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.convert.WritingConverter;
+import org.springframework.data.jdbc.core.convert.Jsr310TimestampBasedConverters;
 import org.springframework.data.relational.core.dialect.Db2Dialect;
 
 /**
@@ -43,6 +44,7 @@ public Collection<Object> getConverters() {
 
 		List<Object> converters = new ArrayList<>(super.getConverters());
 		converters.add(OffsetDateTimeToTimestampConverter.INSTANCE);
+		converters.add(Jsr310TimestampBasedConverters.LocalDateTimeToTimestampConverter.INSTANCE);
 
 		return converters;
 	}

Diff for: spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/dialect/JdbcMySqlDialect.java

@@ -15,17 +15,23 @@
  */
 package org.springframework.data.jdbc.core.dialect;
 
+import static java.time.ZoneId.*;
+
 import java.sql.JDBCType;
+import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Date;
 
 import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.convert.ReadingConverter;
 import org.springframework.data.convert.WritingConverter;
 import org.springframework.data.jdbc.core.convert.JdbcValue;
 import org.springframework.data.relational.core.dialect.Db2Dialect;
 import org.springframework.data.relational.core.dialect.MySqlDialect;
 import org.springframework.data.relational.core.sql.IdentifierProcessing;
+import org.springframework.lang.NonNull;
 
 /**
  * {@link Db2Dialect} that registers JDBC specific converters.
@@ -47,6 +53,7 @@ public Collection<Object> getConverters() {
 
 		ArrayList<Object> converters = new ArrayList<>(super.getConverters());
 		converters.add(OffsetDateTimeToTimestampJdbcValueConverter.INSTANCE);
+		converters.add(LocalDateTimeToDateConverter.INSTANCE);
 
 		return converters;
 	}
@@ -61,4 +68,16 @@ public JdbcValue convert(OffsetDateTime source) {
 			return JdbcValue.of(source, JDBCType.TIMESTAMP);
 		}
 	}
+
+	@ReadingConverter
+	enum LocalDateTimeToDateConverter implements Converter<LocalDateTime, Date> {
+
+		INSTANCE;
+
+		@NonNull
+		@Override
+		public Date convert(LocalDateTime source) {
+			return Date.from(source.atZone(systemDefault()).toInstant());
+		}
+	}
 }

Diff for: spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/BasicJdbcConverterUnitTests.java

@@ -26,6 +26,7 @@
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.util.Date;
@@ -69,12 +70,14 @@ public void testTargetTypesForPropertyType() {
 		SoftAssertions softly = new SoftAssertions();
 
 		checkTargetType(softly, entity, "someEnum", String.class);
-		checkTargetType(softly, entity, "localDateTime", Timestamp.class);
+		checkTargetType(softly, entity, "localDateTime", LocalDateTime.class);
 		checkTargetType(softly, entity, "localDate", Timestamp.class);
 		checkTargetType(softly, entity, "localTime", Timestamp.class);
+		checkTargetType(softly, entity, "zonedDateTime", String.class);
+		checkTargetType(softly, entity, "offsetDateTime", OffsetDateTime.class);
 		checkTargetType(softly, entity, "instant", Timestamp.class);
 		checkTargetType(softly, entity, "date", Date.class);
-		checkTargetType(softly, entity, "zonedDateTime", String.class);
+		checkTargetType(softly, entity, "timestamp", Timestamp.class);
 		checkTargetType(softly, entity, "uuid", UUID.class);
 
 		softly.assertAll();
@@ -165,9 +168,11 @@ private static class DummyEntity {
 		private final LocalDateTime localDateTime;
 		private final LocalDate localDate;
 		private final LocalTime localTime;
+		private final ZonedDateTime zonedDateTime;
+		private final OffsetDateTime offsetDateTime;
 		private final Instant instant;
 		private final Date date;
-		private final ZonedDateTime zonedDateTime;
+		private final Timestamp timestamp;
 		private final AggregateReference<DummyEntity, Long> reference;
 		private final UUID uuid;
 

Diff for: spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/dialect/JdbcDb2DialectUnitTests.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2021 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.jdbc.core.dialect;
+
+import java.sql.Timestamp;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.util.List;
+
+import org.assertj.core.api.SoftAssertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.data.jdbc.core.convert.JdbcCustomConversions;
+
+/**
+ * Tests for {@link JdbcMySqlDialect}.
+ *
+ * @author Jens Schauder
+ */
+class JdbcDb2DialectUnitTests {
+
+	@Test // #974
+	void testCustomConversions() {
+
+		JdbcCustomConversions customConversions = new JdbcCustomConversions(
+				(List<?>) JdbcDb2Dialect.INSTANCE.getConverters());
+
+		SoftAssertions.assertSoftly(softly -> {
+			softly.assertThat(customConversions.getCustomWriteTarget(LocalDateTime.class)).contains(Timestamp.class);
+			softly.assertThat(customConversions.getCustomWriteTarget(OffsetDateTime.class)).contains(Timestamp.class);
+		});
+	}
+}

Diff for: spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/dialect/JdbcMySqlDialectUnitTests.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2021 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.jdbc.core.dialect;
+
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.util.List;
+
+import org.assertj.core.api.SoftAssertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.data.jdbc.core.convert.JdbcCustomConversions;
+import org.springframework.data.jdbc.core.convert.JdbcValue;
+
+/**
+ * Tests for {@link JdbcMySqlDialect}.
+ *
+ * @author Jens Schauder
+ */
+class JdbcMySqlDialectUnitTests {
+
+	@Test // #974
+	void testCustomConversions() {
+
+		JdbcCustomConversions customConversions = new JdbcCustomConversions(
+				(List<?>) new JdbcMySqlDialect().getConverters());
+
+		SoftAssertions.assertSoftly(softly -> {
+
+			softly.assertThat(customConversions.getCustomWriteTarget(LocalDateTime.class)).isEmpty();
+			softly.assertThat(customConversions.getCustomWriteTarget(OffsetDateTime.class)).contains(JdbcValue.class);
+		});
+	}
+}

Diff for: spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/JdbcRepositoryIntegrationTests.java

@@ -27,6 +27,7 @@
 import java.io.IOException;
 import java.sql.ResultSet;
 import java.time.Instant;
+import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
 import java.util.ArrayList;
@@ -49,6 +50,7 @@
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
+import org.springframework.data.jdbc.repository.query.Modifying;
 import org.springframework.data.jdbc.repository.query.Query;
 import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactory;
 import org.springframework.data.jdbc.testing.AssumeFeatureTestExecutionListener;
@@ -492,6 +494,13 @@ public void pageQueryProjectionShouldReturnProjectedEntities() {
 		assertThat(result.getContent().get(0).getName()).isEqualTo("Entity Name");
 	}
 
+	@Test // #974
+	@EnabledOnFeature(TestDatabaseFeatures.Feature.IS_POSTGRES)
+	void intervalCalculation() {
+
+		repository.updateWithIntervalCalculation(23L, LocalDateTime.now());
+	}
+
 	private Instant createDummyBeforeAndAfterNow() {
 
 		Instant now = Instant.now();
@@ -557,6 +566,10 @@ interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {
 
 		@Query("SELECT * FROM DUMMY_ENTITY WHERE OFFSET_DATE_TIME > :threshhold")
 		List<DummyEntity> findByOffsetDateTime(@Param("threshhold") OffsetDateTime threshhold);
+
+		@Modifying
+		@Query("UPDATE dummy_entity SET point_in_time = :start - interval '30 minutes' WHERE id_prop = :id")
+		void updateWithIntervalCalculation(@Param("id") Long id, @Param("start") LocalDateTime start);
 	}
 
 	@Configuration