DATAJDBC-327 - Adds support for conversion to JdbcTypeAware and storing byte[] as binary.

Some JDBC drivers depend on correct explicit type information in order to pass on parameters to the database.
So far CustomConversion had no way to provide that information.
With this change one can use @WritingConverter that converts to JdbcTypeAware in order to provide that information.

byte[] now also get stored as BINARY.

See also: DATAJDBC-239.

Author: schauder

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategy.java

@@ -16,24 +16,25 @@
 package org.springframework.data.jdbc.core;
 
 import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
 
-import java.sql.Connection;
 import java.sql.JDBCType;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
 import org.springframework.dao.DataRetrievalFailureException;
 import org.springframework.dao.EmptyResultDataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.data.jdbc.core.convert.JdbcConverter;
+import org.springframework.data.jdbc.core.convert.JdbcTypeAware;
 import org.springframework.data.jdbc.support.JdbcUtil;
 import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.PropertyHandler;
-import org.springframework.data.relational.core.conversion.RelationalConverter;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
@@ -43,6 +44,7 @@
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.JdbcUtils;
 import org.springframework.jdbc.support.KeyHolder;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -55,27 +57,32 @@
  * @author Thomas Lang
  * @author Bastian Wilhelm
  */
-@RequiredArgsConstructor
 public class DefaultDataAccessStrategy implements DataAccessStrategy {
 
 	private final @NonNull SqlGeneratorSource sqlGeneratorSource;
 	private final @NonNull RelationalMappingContext context;
-	private final @NonNull RelationalConverter converter;
+	private final @NonNull JdbcConverter converter;
 	private final @NonNull NamedParameterJdbcOperations operations;
 	private final @NonNull DataAccessStrategy accessStrategy;
 
+	public DefaultDataAccessStrategy(SqlGeneratorSource sqlGeneratorSource, RelationalMappingContext context,
+			JdbcConverter converter, NamedParameterJdbcOperations operations, @Nullable DataAccessStrategy accessStrategy) {
+
+		this.sqlGeneratorSource = sqlGeneratorSource;
+		this.context = context;
+		this.converter = converter;
+		this.operations = operations;
+		this.accessStrategy = accessStrategy == null ? this : accessStrategy;
+	}
+
 	/**
 	 * Creates a {@link DefaultDataAccessStrategy} which references it self for resolution of recursive data accesses.
 	 * Only suitable if this is the only access strategy in use.
 	 */
 	public DefaultDataAccessStrategy(SqlGeneratorSource sqlGeneratorSource, RelationalMappingContext context,
-			RelationalConverter converter, NamedParameterJdbcOperations operations) {
+			JdbcConverter converter, NamedParameterJdbcOperations operations) {
 
-		this.sqlGeneratorSource = sqlGeneratorSource;
-		this.operations = operations;
-		this.context = context;
-		this.converter = converter;
-		this.accessStrategy = this;
+		this(sqlGeneratorSource, context, converter, operations, null);
 	}
 
 	/*
@@ -97,28 +104,19 @@ public <T> Object insert(T instance, Class<T> domainType, Identifier identifier)
 		KeyHolder holder = new GeneratedKeyHolder();
 		RelationalPersistentEntity<T> persistentEntity = getRequiredPersistentEntity(domainType);
 
-		Map<String, Object> parameters = new LinkedHashMap<>(identifier.size());
-		identifier.forEach((name, value, type) -> {
-			parameters.put(name, converter.writeValue(value, ClassTypeInformation.from(type)));
-		});
+		MapSqlParameterSource parameterSource = getParameterSource(instance, persistentEntity, "", true);
 
-		MapSqlParameterSource parameterSource = getPropertyMap(instance, persistentEntity, "");
+		identifier.forEach((name, value, type) -> addConvertedPropertyValue(parameterSource, name, value, type));
 
 		Object idValue = getIdValueOrNull(instance, persistentEntity);
-		RelationalPersistentProperty idProperty = persistentEntity.getIdProperty();
-
 		if (idValue != null) {
 
-			Assert.notNull(idProperty, "Since we have a non-null idValue, we must have an idProperty as well.");
-
-			parameters.put(idProperty.getColumnName(),
-					converter.writeValue(idValue, ClassTypeInformation.from(idProperty.getColumnType())));
+			RelationalPersistentProperty idProperty = persistentEntity.getRequiredIdProperty();
+			addConvertedPropertyValue(parameterSource, idProperty, idValue, idProperty.getColumnName());
 		}
 
-		parameters.forEach(parameterSource::addValue);
-
 		operations.update( //
-				sql(domainType).getInsert(parameters.keySet()), //
+				sql(domainType).getInsert(new HashSet<>(Arrays.asList(parameterSource.getParameterNames()))), //
 				parameterSource, //
 				holder //
 		);
@@ -135,7 +133,8 @@ public <S> boolean update(S instance, Class<S> domainType) {
 
 		RelationalPersistentEntity<S> persistentEntity = getRequiredPersistentEntity(domainType);
 
-		return operations.update(sql(domainType).getUpdate(), getPropertyMap(instance, persistentEntity, "")) != 0;
+		return operations.update(sql(domainType).getUpdate(),
+				getParameterSource(instance, persistentEntity, "", false)) != 0;
 	}
 
 	/*
@@ -240,17 +239,14 @@ public <T> Iterable<T> findAll(Class<T> domainType) {
 	@Override
 	public <T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType) {
 
-		String findAllInListSql = sql(domainType).getFindAllInList();
-		Class<?> targetType = getRequiredPersistentEntity(domainType).getRequiredIdProperty().getColumnType();
+		RelationalPersistentProperty idProperty = getRequiredPersistentEntity(domainType).getRequiredIdProperty();
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
 
-		MapSqlParameterSource parameter = new MapSqlParameterSource( //
-				"ids", //
-				StreamSupport.stream(ids.spliterator(), false) //
-						.map(id -> converter.writeValue(id, ClassTypeInformation.from(targetType))) //
-						.collect(Collectors.toList()) //
-		);
+		addConvertedPropertyValuesAsList(parameterSource, idProperty, ids, "ids");
+
+		String findAllInListSql = sql(domainType).getFindAllInList();
 
-		return operations.query(findAllInListSql, parameter, (RowMapper<T>) getEntityRowMapper(domainType));
+		return operations.query(findAllInListSql, parameterSource, (RowMapper<T>) getEntityRowMapper(domainType));
 	}
 
 	/*
@@ -292,15 +288,18 @@ public <T> boolean existsById(Object id, Class<T> domainType) {
 		return result;
 	}
 
-	private <S, T> MapSqlParameterSource getPropertyMap(S instance, RelationalPersistentEntity<S> persistentEntity,
-			String prefix) {
+	private <S, T> MapSqlParameterSource getParameterSource(S instance, RelationalPersistentEntity<S> persistentEntity,
+			String prefix, boolean skipId) {
 
 		MapSqlParameterSource parameters = new MapSqlParameterSource();
 
 		PersistentPropertyAccessor<S> propertyAccessor = persistentEntity.getPropertyAccessor(instance);
 
 		persistentEntity.doWithProperties((PropertyHandler<RelationalPersistentProperty>) property -> {
 
+			if (skipId && property.isIdProperty()) {
+				return;
+			}
 			if (property.isEntity() && !property.isEmbedded()) {
 				return;
 			}
@@ -309,42 +308,21 @@ private <S, T> MapSqlParameterSource getPropertyMap(S instance, RelationalPersis
 
 				Object value = propertyAccessor.getProperty(property);
 				RelationalPersistentEntity<?> embeddedEntity = context.getPersistentEntity(property.getType());
-				MapSqlParameterSource additionalParameters = getPropertyMap((T) value,
-						(RelationalPersistentEntity<T>) embeddedEntity, prefix + property.getEmbeddedPrefix());
+				MapSqlParameterSource additionalParameters = getParameterSource((T) value,
+						(RelationalPersistentEntity<T>) embeddedEntity, prefix + property.getEmbeddedPrefix(), skipId);
 				parameters.addValues(additionalParameters.getValues());
 			} else {
 
 				Object value = propertyAccessor.getProperty(property);
-				Object convertedValue = convertForWrite(property, value);
+				String paramName = prefix + property.getColumnName();
 
-				parameters.addValue(prefix + property.getColumnName(), convertedValue,
-						JdbcUtil.sqlTypeFor(property.getColumnType()));
+				addConvertedPropertyValue(parameters, property, value, paramName);
 			}
 		});
 
 		return parameters;
 	}
 
-	@Nullable
-	private Object convertForWrite(RelationalPersistentProperty property, @Nullable Object value) {
-
-		Object convertedValue = converter.writeValue(value, ClassTypeInformation.from(property.getColumnType()));
-
-		if (convertedValue == null || !convertedValue.getClass().isArray()) {
-			return convertedValue;
-		}
-
-		Class<?> componentType = convertedValue.getClass();
-		while (componentType.isArray()) {
-			componentType = componentType.getComponentType();
-		}
-
-		String typeName = JDBCType.valueOf(JdbcUtil.sqlTypeFor(componentType)).getName();
-
-		return operations.getJdbcOperations()
-				.execute((Connection c) -> c.createArrayOf(typeName, (Object[]) convertedValue));
-	}
-
 	@SuppressWarnings("unchecked")
 	@Nullable
 	private <S, ID> ID getIdValueOrNull(S instance, RelationalPersistentEntity<S> persistentEntity) {
@@ -398,8 +376,65 @@ private RowMapper<?> getMapEntityRowMapper(RelationalPersistentProperty property
 
 	private <T> MapSqlParameterSource createIdParameterSource(Object id, Class<T> domainType) {
 
-		Class<?> columnType = getRequiredPersistentEntity(domainType).getRequiredIdProperty().getColumnType();
-		return new MapSqlParameterSource("id", converter.writeValue(id, ClassTypeInformation.from(columnType)));
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+
+		addConvertedPropertyValue( //
+				parameterSource, //
+				getRequiredPersistentEntity(domainType).getRequiredIdProperty(), //
+				id, //
+				"id" //
+		);
+		return parameterSource;
+	}
+
+	private void addConvertedPropertyValue(MapSqlParameterSource parameterSource, RelationalPersistentProperty property,
+			Object value, String paramName) {
+
+		JdbcTypeAware jdbcTypeAware = converter.writeTypeAware( //
+				value, //
+				property.getColumnType(), //
+				property.getSqlType() //
+		);
+
+		parameterSource.addValue(paramName, jdbcTypeAware.getValue(), JdbcUtil.sqlTypeFor(jdbcTypeAware.getJdbcType()));
+	}
+
+	private void addConvertedPropertyValue(MapSqlParameterSource parameterSource, String name, Object value,
+			Class<?> type) {
+
+		JdbcTypeAware jdbcTypeAware = converter.writeTypeAware( //
+				value, //
+				type, //
+				JdbcUtil.sqlTypeFor(type) //
+		);
+
+		parameterSource.addValue( //
+				name, //
+				jdbcTypeAware.getValue(), //
+				JdbcUtil.sqlTypeFor(jdbcTypeAware.getJdbcType()) //
+		);
+	}
+
+	private void addConvertedPropertyValuesAsList(MapSqlParameterSource parameterSource,
+			RelationalPersistentProperty property, Iterable<?> values, String paramName) {
+
+		List<Object> convertedIds = new ArrayList<>();
+		JdbcTypeAware jdbcTypeAware = null;
+		for (Object id : values) {
+
+			Class<?> columnType = property.getColumnType();
+			int sqlType = property.getSqlType();
+
+			jdbcTypeAware = converter.writeTypeAware(id, columnType, sqlType);
+			convertedIds.add(jdbcTypeAware.getValue());
+		}
+
+		Assert.notNull(jdbcTypeAware, "JdbcTypeAware must be not null at this point. Please report this as a bug.");
+
+		JDBCType jdbcType = jdbcTypeAware.getJdbcType();
+		int typeNumber = jdbcType == null ? JdbcUtils.TYPE_UNKNOWN : jdbcType.getVendorTypeNumber();
+
+		parameterSource.addValue(paramName, convertedIds, typeNumber);
 	}
 
 	@SuppressWarnings("unchecked")