Spring/spring-data-relational
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed deprecations.

Browse Source 
Removed deprecated API and usasage of deprecated API.

Closes #1340
This commit is contained in:
Jens Schauder
2022-09-27 13:03:52 +02:00
parent 98ef3df478
commit f326897950
20 changed files with 72 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/BasicJdbcConverter.java
View File

@@ -33,6 +33,7 @@ import org.springframework.data.convert.CustomConversions;
import org.springframework.data.jdbc.core.mapping.AggregateReference; import org.springframework.data.jdbc.core.mapping.AggregateReference;
import org.springframework.data.jdbc.core.mapping.JdbcValue; import org.springframework.data.jdbc.core.mapping.JdbcValue;
import org.springframework.data.jdbc.support.JdbcUtil; import org.springframework.data.jdbc.support.JdbcUtil;
import org.springframework.data.mapping.InstanceCreatorMetadata;
import org.springframework.data.mapping.Parameter; import org.springframework.data.mapping.Parameter;
import org.springframework.data.mapping.PersistentPropertyAccessor; import org.springframework.data.mapping.PersistentPropertyAccessor;
import org.springframework.data.mapping.PersistentPropertyPath; import org.springframework.data.mapping.PersistentPropertyPath;
@@ -50,7 +51,7 @@ import org.springframework.data.relational.core.mapping.PersistentPropertyPathEx
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty; import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.core.sql.IdentifierProcessing; import org.springframework.data.relational.core.sql.IdentifierProcessing;
import org.springframework.data.util.ClassTypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.data.util.TypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Nullable; import org.springframework.lang.Nullable;
import org.springframework.util.Assert; import org.springframework.util.Assert;
@@ -267,7 +268,7 @@ public class BasicJdbcConverter extends BasicRelationalConverter implements Jdbc
return jdbcValue; return jdbcValue;
} }
Object convertedValue = writeValue(value, ClassTypeInformation.from(columnType)); Object convertedValue = writeValue(value, TypeInformation.of(columnType));
if (convertedValue == null || !convertedValue.getClass().isArray()) { if (convertedValue == null || !convertedValue.getClass().isArray()) {
@@ -293,7 +294,7 @@ public class BasicJdbcConverter extends BasicRelationalConverter implements Jdbc
if (canWriteAsJdbcValue(value)) { if (canWriteAsJdbcValue(value)) {
Object converted = writeValue(value, ClassTypeInformation.from(JdbcValue.class)); Object converted = writeValue(value, TypeInformation.of(JdbcValue.class));
if (converted instanceof JdbcValue) { if (converted instanceof JdbcValue) {
return (JdbcValue) converted; return (JdbcValue) converted;
} }
@@ -414,11 +415,11 @@ public class BasicJdbcConverter extends BasicRelationalConverter implements Jdbc
private T populateProperties(T instance, @Nullable Object idValue) { private T populateProperties(T instance, @Nullable Object idValue) {
PersistentPropertyAccessor<T> propertyAccessor = getPropertyAccessor(entity, instance); PersistentPropertyAccessor<T> propertyAccessor = getPropertyAccessor(entity, instance);
PreferredConstructor<T, RelationalPersistentProperty> persistenceConstructor = entity.getPersistenceConstructor(); InstanceCreatorMetadata<RelationalPersistentProperty> creatorMetadata = entity.getInstanceCreatorMetadata();
entity.doWithAll(property -> { entity.doWithAll(property -> {
if (persistenceConstructor != null && persistenceConstructor.isConstructorParameter(property)) { if (creatorMetadata != null && creatorMetadata.isCreatorParameter(property)) {
return; return;
} }
@@ -548,10 +549,10 @@ public class BasicJdbcConverter extends BasicRelationalConverter implements Jdbc
private T createInstanceInternal(@Nullable Object idValue) { private T createInstanceInternal(@Nullable Object idValue) {
PreferredConstructor<T, RelationalPersistentProperty> persistenceConstructor = entity.getPersistenceConstructor(); InstanceCreatorMetadata<RelationalPersistentProperty> creatorMetadata = entity.getInstanceCreatorMetadata();
ParameterValueProvider<RelationalPersistentProperty> provider; ParameterValueProvider<RelationalPersistentProperty> provider;
if (persistenceConstructor != null && persistenceConstructor.hasParameters()) { if (creatorMetadata != null && creatorMetadata.hasParameters()) {
SpELExpressionEvaluator expressionEvaluator = new DefaultSpELExpressionEvaluator(accessor, spELContext); SpELExpressionEvaluator expressionEvaluator = new DefaultSpELExpressionEvaluator(accessor, spELContext);
provider = new SpELExpressionParameterValueProvider<>(expressionEvaluator, getConversionService(), provider = new SpELExpressionParameterValueProvider<>(expressionEvaluator, getConversionService(),

16
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/QueryMapper.java
View File

@@ -41,7 +41,7 @@ import org.springframework.data.relational.core.query.CriteriaDefinition;
import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator; import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator;
import org.springframework.data.relational.core.query.ValueFunction; import org.springframework.data.relational.core.query.ValueFunction;
import org.springframework.data.relational.core.sql.*; import org.springframework.data.relational.core.sql.*;
import org.springframework.data.util.ClassTypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.data.util.Pair; import org.springframework.data.util.Pair;
import org.springframework.data.util.TypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource; import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
@@ -441,11 +441,11 @@ public class QueryMapper {
Object first = convertValue(pair.getFirst(), typeInformation.getActualType() != null // Object first = convertValue(pair.getFirst(), typeInformation.getActualType() != null //
? typeInformation.getRequiredActualType() ? typeInformation.getRequiredActualType()
: ClassTypeInformation.OBJECT); : TypeInformation.OBJECT);
Object second = convertValue(pair.getSecond(), typeInformation.getActualType() != null // Object second = convertValue(pair.getSecond(), typeInformation.getActualType() != null //
? typeInformation.getRequiredActualType() ? typeInformation.getRequiredActualType()
: ClassTypeInformation.OBJECT); : TypeInformation.OBJECT);
return Pair.of(first, second); return Pair.of(first, second);
} }
@@ -457,14 +457,14 @@ public class QueryMapper {
for (Object o : (Iterable<?>) value) { for (Object o : (Iterable<?>) value) {
mapped.add(convertValue(o, typeInformation.getActualType() != null ? typeInformation.getRequiredActualType() mapped.add(convertValue(o, typeInformation.getActualType() != null ? typeInformation.getRequiredActualType()
: ClassTypeInformation.OBJECT)); : TypeInformation.OBJECT));
} }
return mapped; return mapped;
} }
if (value.getClass().isArray() if (value.getClass().isArray()
&& (ClassTypeInformation.OBJECT.equals(typeInformation) || typeInformation.isCollectionLike())) { && (TypeInformation.OBJECT.equals(typeInformation) || typeInformation.isCollectionLike())) {
return value; return value;
} }
@@ -587,7 +587,7 @@ public class QueryMapper {
private Expression bindBoolean(Column column, MapSqlParameterSource parameterSource, boolean value) { private Expression bindBoolean(Column column, MapSqlParameterSource parameterSource, boolean value) {
Object converted = converter.writeValue(value, ClassTypeInformation.OBJECT); Object converted = converter.writeValue(value, TypeInformation.OBJECT);
return bind(converted, JDBCType.BIT, parameterSource, column.getName().getReference()); return bind(converted, JDBCType.BIT, parameterSource, column.getName().getReference());
} }
@@ -678,7 +678,7 @@ public class QueryMapper {
} }
public TypeInformation<?> getTypeHint() { public TypeInformation<?> getTypeHint() {
return ClassTypeInformation.OBJECT; return TypeInformation.OBJECT;
} }
public SQLType getSqlType() { public SQLType getSqlType() {
@@ -808,7 +808,7 @@ public class QueryMapper {
} }
if (this.property.getType().isPrimitive()) { if (this.property.getType().isPrimitive()) {
return ClassTypeInformation.from(ClassUtils.resolvePrimitiveIfNecessary(this.property.getType())); return TypeInformation.of(ClassUtils.resolvePrimitiveIfNecessary(this.property.getType()));
} }
if (this.property.getType().isArray()) { if (this.property.getType().isArray()) {

5
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/StringBasedJdbcQuery.java
View File

@@ -45,7 +45,6 @@ import org.springframework.lang.Nullable;
import org.springframework.util.Assert; import org.springframework.util.Assert;
import org.springframework.util.ClassUtils; import org.springframework.util.ClassUtils;
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
/** /**
* A query to be executed based on a repository method, it's annotated SQL query and the arguments provided to the * A query to be executed based on a repository method, it's annotated SQL query and the arguments provided to the
@@ -211,7 +210,7 @@ public class StringBasedJdbcQuery extends AbstractJdbcQuery {
String resultSetExtractorRef = queryMethod.getResultSetExtractorRef(); String resultSetExtractorRef = queryMethod.getResultSetExtractorRef();
if (!StringUtils.isEmpty(resultSetExtractorRef)) { if (!ObjectUtils.isEmpty(resultSetExtractorRef)) {
Assert.notNull(beanFactory, "When a ResultSetExtractorRef is specified the BeanFactory must not be null"); Assert.notNull(beanFactory, "When a ResultSetExtractorRef is specified the BeanFactory must not be null");
@@ -253,7 +252,7 @@ public class StringBasedJdbcQuery extends AbstractJdbcQuery {
String rowMapperRef = queryMethod.getRowMapperRef(); String rowMapperRef = queryMethod.getRowMapperRef();
if (!StringUtils.isEmpty(rowMapperRef)) { if (!ObjectUtils.isEmpty(rowMapperRef)) {
Assert.notNull(beanFactory, "When a RowMapperRef is specified the BeanFactory must not be null"); Assert.notNull(beanFactory, "When a RowMapperRef is specified the BeanFactory must not be null");

4
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/BasicJdbcConverterUnitTests.java
View File

@@ -44,7 +44,7 @@ import org.springframework.data.jdbc.support.JdbcUtil;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty; import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.core.sql.IdentifierProcessing; import org.springframework.data.relational.core.sql.IdentifierProcessing;
import org.springframework.data.util.ClassTypeInformation; import org.springframework.data.util.TypeInformation;
/** /**
* Unit tests for {@link BasicJdbcConverter}. * Unit tests for {@link BasicJdbcConverter}.
@@ -147,7 +147,7 @@ public class BasicJdbcConverterUnitTests {
RelationalPersistentProperty property = persistentEntity.getRequiredPersistentProperty(propertyName); RelationalPersistentProperty property = persistentEntity.getRequiredPersistentProperty(propertyName);
Object converted = converter.writeValue(value, ClassTypeInformation.from(converter.getColumnType(property))); Object converted = converter.writeValue(value, TypeInformation.of(converter.getColumnType(property)));
Object convertedBack = converter.readValue(converted, property.getTypeInformation()); Object convertedBack = converter.readValue(converted, property.getTypeInformation());
softly.assertThat(convertedBack).describedAs(propertyName).isEqualTo(value); softly.assertThat(convertedBack).describedAs(propertyName).isEqualTo(value);

5
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/BasicRelationalConverterAggregateReferenceUnitTests.java
View File

@@ -20,13 +20,12 @@ import static org.mockito.Mockito.*;
import org.assertj.core.api.Assertions; import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.data.annotation.Id; import org.springframework.data.annotation.Id;
import org.springframework.data.jdbc.core.mapping.AggregateReference; import org.springframework.data.jdbc.core.mapping.AggregateReference;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty; import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.util.ClassTypeInformation; import org.springframework.data.util.TypeInformation;
/** /**
* Unit tests for the handling of {@link AggregateReference}s in the * Unit tests for the handling of {@link AggregateReference}s in the
@@ -59,7 +58,7 @@ public class BasicRelationalConverterAggregateReferenceUnitTests {
AggregateReference<Object, Integer> reference = AggregateReference.to(23); AggregateReference<Object, Integer> reference = AggregateReference.to(23);
Object writeValue = converter.writeValue(reference, ClassTypeInformation.from(converter.getColumnType(property))); Object writeValue = converter.writeValue(reference, TypeInformation.of(converter.getColumnType(property)));
Assertions.assertThat(writeValue).isEqualTo(23L); Assertions.assertThat(writeValue).isEqualTo(23L);
} }

4
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/EntityRowMapperUnitTests.java
View File

@@ -49,7 +49,7 @@ import org.mockito.ArgumentMatchers;
import org.mockito.invocation.InvocationOnMock; import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer; import org.mockito.stubbing.Answer;
import org.springframework.data.annotation.Id; import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.PersistenceConstructor; import org.springframework.data.annotation.PersistenceCreator;
import org.springframework.data.annotation.Transient; import org.springframework.data.annotation.Transient;
import org.springframework.data.jdbc.core.mapping.AggregateReference; import org.springframework.data.jdbc.core.mapping.AggregateReference;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext; import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
@@ -755,7 +755,7 @@ public class EntityRowMapperUnitTests {
String two; String two;
final String three; final String three;
@PersistenceConstructor @PersistenceCreator
MixedProperties(String one) { MixedProperties(String one) {
this.one = one; this.one = one;
this.three = "unset"; this.three = "unset";

6
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/JdbcRepositoryConfigExtensionUnitTests.java
View File

@@ -26,7 +26,7 @@ import org.springframework.core.env.Environment;
import org.springframework.core.env.StandardEnvironment; import org.springframework.core.env.StandardEnvironment;
import org.springframework.core.io.ResourceLoader; import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.StandardAnnotationMetadata; import org.springframework.core.type.AnnotationMetadata;
import org.springframework.data.relational.core.mapping.Table; import org.springframework.data.relational.core.mapping.Table;
import org.springframework.data.repository.Repository; import org.springframework.data.repository.Repository;
import org.springframework.data.repository.config.AnnotationRepositoryConfigurationSource; import org.springframework.data.repository.config.AnnotationRepositoryConfigurationSource;
@@ -40,13 +40,13 @@ import org.springframework.data.repository.config.RepositoryConfigurationSource;
*/ */
public class JdbcRepositoryConfigExtensionUnitTests { public class JdbcRepositoryConfigExtensionUnitTests {
StandardAnnotationMetadata metadata = new StandardAnnotationMetadata(Config.class, true); AnnotationMetadata metadata = AnnotationMetadata.introspect(Config.class);
ResourceLoader loader = new PathMatchingResourcePatternResolver(); ResourceLoader loader = new PathMatchingResourcePatternResolver();
Environment environment = new StandardEnvironment(); Environment environment = new StandardEnvironment();
BeanDefinitionRegistry registry = new DefaultListableBeanFactory(); BeanDefinitionRegistry registry = new DefaultListableBeanFactory();
RepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(metadata, RepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(metadata,
EnableJdbcRepositories.class, loader, environment, registry); EnableJdbcRepositories.class, loader, environment, registry, null);
@Test // DATAJPA-437 @Test // DATAJPA-437
public void isStrictMatchOnlyIfDomainTypeIsAnnotatedWithDocument() { public void isStrictMatchOnlyIfDomainTypeIsAnnotatedWithDocument() {

4
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/query/JdbcQueryMethodUnitTests.java
View File

@@ -32,7 +32,7 @@ import org.springframework.data.relational.repository.Lock;
import org.springframework.data.repository.core.NamedQueries; import org.springframework.data.repository.core.NamedQueries;
import org.springframework.data.repository.core.RepositoryMetadata; import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.core.support.PropertiesBasedNamedQueries; import org.springframework.data.repository.core.support.PropertiesBasedNamedQueries;
import org.springframework.data.util.ClassTypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.jdbc.core.RowMapper; import org.springframework.jdbc.core.RowMapper;
/** /**
@@ -67,7 +67,7 @@ public class JdbcQueryMethodUnitTests {
metadata = mock(RepositoryMetadata.class); metadata = mock(RepositoryMetadata.class);
doReturn(String.class).when(metadata).getReturnedDomainClass(any(Method.class)); doReturn(String.class).when(metadata).getReturnedDomainClass(any(Method.class));
doReturn(ClassTypeInformation.from(String.class)).when(metadata).getReturnType(any(Method.class)); doReturn(TypeInformation.of(String.class)).when(metadata).getReturnType(any(Method.class));
} }
@Test // DATAJDBC-165 @Test // DATAJDBC-165

5
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategyUnitTests.java
View File

@@ -25,7 +25,6 @@ import java.util.stream.Stream;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.MethodSource;
@@ -42,7 +41,7 @@ import org.springframework.data.repository.core.NamedQueries;
import org.springframework.data.repository.core.RepositoryMetadata; import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.query.QueryLookupStrategy; import org.springframework.data.repository.query.QueryLookupStrategy;
import org.springframework.data.repository.query.RepositoryQuery; import org.springframework.data.repository.query.RepositoryQuery;
import org.springframework.data.util.ClassTypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.jdbc.core.RowMapper; import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
import org.springframework.jdbc.core.namedparam.SqlParameterSource; import org.springframework.jdbc.core.namedparam.SqlParameterSource;
@@ -77,7 +76,7 @@ class JdbcQueryLookupStrategyUnitTests {
this.metadata = mock(RepositoryMetadata.class); this.metadata = mock(RepositoryMetadata.class);
doReturn(NumberFormat.class).when(metadata).getReturnedDomainClass(any(Method.class)); doReturn(NumberFormat.class).when(metadata).getReturnedDomainClass(any(Method.class));
doReturn(ClassTypeInformation.from(NumberFormat.class)).when(metadata).getReturnType(any(Method.class)); doReturn(TypeInformation.of(NumberFormat.class)).when(metadata).getReturnType(any(Method.class));
} }
@Test // DATAJDBC-166 @Test // DATAJDBC-166

15
spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/convert/MappingR2dbcConverter.java
View File

@@ -50,7 +50,6 @@ import org.springframework.data.relational.core.conversion.RelationalConverter;
import org.springframework.data.relational.core.dialect.ArrayColumns; import org.springframework.data.relational.core.dialect.ArrayColumns;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty; import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.util.ClassTypeInformation;
import org.springframework.data.util.TypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Nullable; import org.springframework.lang.Nullable;
import org.springframework.r2dbc.core.Parameter; import org.springframework.r2dbc.core.Parameter;
@@ -107,7 +106,7 @@ public class MappingR2dbcConverter extends BasicRelationalConverter implements R
@Override @Override
public <R> R read(Class<R> type, Row row, @Nullable RowMetadata metadata) { public <R> R read(Class<R> type, Row row, @Nullable RowMetadata metadata) {
TypeInformation<? extends R> typeInfo = ClassTypeInformation.from(type); TypeInformation<? extends R> typeInfo = TypeInformation.of(type);
Class<? extends R> rawType = typeInfo.getType(); Class<? extends R> rawType = typeInfo.getType();
if (Row.class.isAssignableFrom(rawType)) { if (Row.class.isAssignableFrom(rawType)) {
@@ -132,7 +131,7 @@ public class MappingR2dbcConverter extends BasicRelationalConverter implements R
for (RelationalPersistentProperty property : entity) { for (RelationalPersistentProperty property : entity) {
if (entity.isConstructorArgument(property)) { if (entity.isCreatorArgument(property)) {
continue; continue;
} }
@@ -185,12 +184,10 @@ public class MappingR2dbcConverter extends BasicRelationalConverter implements R
return readValue(value, property.getTypeInformation()); return readValue(value, property.getTypeInformation());
} catch (Exception o_O) { } catch (Exception o_O) {
throw new MappingException(String.format("Could not read property %s from column %s", property, identifier), throw new MappingException(String.format("Could not read property %s from column %s", property, identifier), o_O);
o_O);
} }
} }
public Object readValue(@Nullable Object value, TypeInformation<?> type) { public Object readValue(@Nullable Object value, TypeInformation<?> type) {
if (null == value) { if (null == value) {
@@ -224,7 +221,7 @@ public class MappingR2dbcConverter extends BasicRelationalConverter implements R
TypeInformation<?> componentType = targetType.getComponentType() != null // TypeInformation<?> componentType = targetType.getComponentType() != null //
? targetType.getComponentType() // ? targetType.getComponentType() //
: ClassTypeInformation.OBJECT; : TypeInformation.OBJECT;
Class<?> rawComponentType = componentType.getType(); Class<?> rawComponentType = componentType.getType();
Collection<Object> items = targetType.getType().isArray() // Collection<Object> items = targetType.getType().isArray() //
@@ -302,7 +299,7 @@ public class MappingR2dbcConverter extends BasicRelationalConverter implements R
getConversionService()); getConversionService());
for (RelationalPersistentProperty p : entity) { for (RelationalPersistentProperty p : entity) {
if (!entity.isConstructorArgument(property)) { if (!entity.isCreatorArgument(property)) {
propertyAccessor.setProperty(p, readFrom(row, metadata, p, prefix)); propertyAccessor.setProperty(p, readFrom(row, metadata, p, prefix));
} }
} }
@@ -405,7 +402,7 @@ public class MappingR2dbcConverter extends BasicRelationalConverter implements R
private void writePropertyInternal(OutboundRow sink, Object value, boolean isNew, private void writePropertyInternal(OutboundRow sink, Object value, boolean isNew,
RelationalPersistentProperty property) { RelationalPersistentProperty property) {
TypeInformation<?> valueType = ClassTypeInformation.from(value.getClass()); TypeInformation<?> valueType = TypeInformation.of(value.getClass());
if (valueType.isCollectionLike()) { if (valueType.isCollectionLike()) {

15
spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/convert/R2dbcCustomConversions.java
View File

@@ -16,6 +16,7 @@ import org.springframework.data.r2dbc.mapping.R2dbcSimpleTypeHolder;
* {@link org.springframework.data.mapping.model.SimpleTypeHolder} * {@link org.springframework.data.mapping.model.SimpleTypeHolder}
* *
* @author Mark Paluch * @author Mark Paluch
* @author Jens Schauder
* @see CustomConversions * @see CustomConversions
* @see org.springframework.data.mapping.model.SimpleTypeHolder * @see org.springframework.data.mapping.model.SimpleTypeHolder
*/ */
@@ -33,20 +34,6 @@ public class R2dbcCustomConversions extends CustomConversions {
STORE_CONVERSIONS = StoreConversions.of(R2dbcSimpleTypeHolder.HOLDER, STORE_CONVERTERS); STORE_CONVERSIONS = StoreConversions.of(R2dbcSimpleTypeHolder.HOLDER, STORE_CONVERTERS);
} }
/**
* Create a new {@link R2dbcCustomConversions} instance registering the given converters.
*
* @param converters must not be {@literal null}.
* @deprecated since 1.3, use {@link #of(R2dbcDialect, Object...)} or
* {@link #R2dbcCustomConversions(StoreConversions, Collection)} directly to consider dialect-native
* simple types. Use {@link CustomConversions.StoreConversions#NONE} to omit store-specific converters.
*/
@Deprecated
public R2dbcCustomConversions(Collection<?> converters) {
super(new R2dbcCustomConversionsConfiguration(STORE_CONVERSIONS,
converters instanceof List ? (List<?>) converters : new ArrayList<>(converters)));
}
/** /**
* Create a new {@link R2dbcCustomConversions} instance registering the given converters. * Create a new {@link R2dbcCustomConversions} instance registering the given converters.
* *

18
spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/query/QueryMapper.java
View File

@@ -38,7 +38,7 @@ import org.springframework.data.relational.core.query.CriteriaDefinition;
import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator; import org.springframework.data.relational.core.query.CriteriaDefinition.Comparator;
import org.springframework.data.relational.core.query.ValueFunction; import org.springframework.data.relational.core.query.ValueFunction;
import org.springframework.data.relational.core.sql.*; import org.springframework.data.relational.core.sql.*;
import org.springframework.data.util.ClassTypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.data.util.Pair; import org.springframework.data.util.Pair;
import org.springframework.data.util.TypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Nullable; import org.springframework.lang.Nullable;
@@ -392,7 +392,7 @@ public class QueryMapper {
return Parameter.empty(converter.getTargetType(value.getType())); return Parameter.empty(converter.getTargetType(value.getType()));
} }
return Parameter.from(convertValue(value.getValue(), ClassTypeInformation.OBJECT)); return Parameter.from(convertValue(value.getValue(), TypeInformation.OBJECT));
} }
@Nullable @Nullable
@@ -408,11 +408,11 @@ public class QueryMapper {
Object first = convertValue(pair.getFirst(), Object first = convertValue(pair.getFirst(),
typeInformation.getActualType() != null ? typeInformation.getRequiredActualType() typeInformation.getActualType() != null ? typeInformation.getRequiredActualType()
: ClassTypeInformation.OBJECT); : TypeInformation.OBJECT);
Object second = convertValue(pair.getSecond(), Object second = convertValue(pair.getSecond(),
typeInformation.getActualType() != null ? typeInformation.getRequiredActualType() typeInformation.getActualType() != null ? typeInformation.getRequiredActualType()
: ClassTypeInformation.OBJECT); : TypeInformation.OBJECT);
return Pair.of(first, second); return Pair.of(first, second);
} }
@@ -423,14 +423,14 @@ public class QueryMapper {
for (Object o : (Iterable<?>) value) { for (Object o : (Iterable<?>) value) {
mapped.add(convertValue(o, typeInformation.getActualType() != null ? typeInformation.getRequiredActualType() mapped.add(convertValue(o, typeInformation.getActualType() != null ? typeInformation.getRequiredActualType()
: ClassTypeInformation.OBJECT)); : TypeInformation.OBJECT));
} }
return mapped; return mapped;
} }
if (value.getClass().isArray() if (value.getClass().isArray()
&& (ClassTypeInformation.OBJECT.equals(typeInformation) || typeInformation.isCollectionLike())) { && (TypeInformation.OBJECT.equals(typeInformation) || typeInformation.isCollectionLike())) {
return value; return value;
} }
@@ -633,7 +633,7 @@ public class QueryMapper {
} }
public TypeInformation<?> getTypeHint() { public TypeInformation<?> getTypeHint() {
return ClassTypeInformation.OBJECT; return TypeInformation.OBJECT;
} }
} }
@@ -734,7 +734,7 @@ public class QueryMapper {
} }
if (this.property.getType().isPrimitive()) { if (this.property.getType().isPrimitive()) {
return ClassTypeInformation.from(ClassUtils.resolvePrimitiveIfNecessary(this.property.getType())); return TypeInformation.of(ClassUtils.resolvePrimitiveIfNecessary(this.property.getType()));
} }
if (this.property.getType().isArray()) { if (this.property.getType().isArray()) {
@@ -743,7 +743,7 @@ public class QueryMapper {
if (this.property.getType().isInterface() if (this.property.getType().isInterface()
|| (java.lang.reflect.Modifier.isAbstract(this.property.getType().getModifiers()))) { || (java.lang.reflect.Modifier.isAbstract(this.property.getType().getModifiers()))) {
return ClassTypeInformation.OBJECT; return TypeInformation.OBJECT;
} }
return this.property.getTypeInformation(); return this.property.getTypeInformation();

9
spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/repository/query/R2dbcQueryMethod.java
View File

@@ -28,11 +28,11 @@ import org.springframework.data.domain.Slice;
import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort;
import org.springframework.data.mapping.context.MappingContext; import org.springframework.data.mapping.context.MappingContext;
import org.springframework.data.projection.ProjectionFactory; import org.springframework.data.projection.ProjectionFactory;
import org.springframework.data.relational.repository.Lock;
import org.springframework.data.r2dbc.repository.Modifying; import org.springframework.data.r2dbc.repository.Modifying;
import org.springframework.data.r2dbc.repository.Query; import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty; import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.repository.Lock;
import org.springframework.data.relational.repository.query.RelationalEntityMetadata; import org.springframework.data.relational.repository.query.RelationalEntityMetadata;
import org.springframework.data.relational.repository.query.RelationalParameters; import org.springframework.data.relational.repository.query.RelationalParameters;
import org.springframework.data.relational.repository.query.SimpleRelationalEntityMetadata; import org.springframework.data.relational.repository.query.SimpleRelationalEntityMetadata;
@@ -41,7 +41,6 @@ import org.springframework.data.repository.query.Parameter;
import org.springframework.data.repository.query.QueryMethod; import org.springframework.data.repository.query.QueryMethod;
import org.springframework.data.repository.util.ReactiveWrapperConverters; import org.springframework.data.repository.util.ReactiveWrapperConverters;
import org.springframework.data.repository.util.ReactiveWrappers; import org.springframework.data.repository.util.ReactiveWrappers;
import org.springframework.data.util.ClassTypeInformation;
import org.springframework.data.util.Lazy; import org.springframework.data.util.Lazy;
import org.springframework.data.util.ReflectionUtils; import org.springframework.data.util.ReflectionUtils;
import org.springframework.data.util.TypeInformation; import org.springframework.data.util.TypeInformation;
@@ -59,10 +58,10 @@ import org.springframework.util.ClassUtils;
public class R2dbcQueryMethod extends QueryMethod { public class R2dbcQueryMethod extends QueryMethod {
@SuppressWarnings("rawtypes") // @SuppressWarnings("rawtypes") //
private static final ClassTypeInformation<Page> PAGE_TYPE = ClassTypeInformation.from(Page.class); private static final TypeInformation<Page> PAGE_TYPE = TypeInformation.of(Page.class);
@SuppressWarnings("rawtypes") // @SuppressWarnings("rawtypes") //
private static final ClassTypeInformation<Slice> SLICE_TYPE = ClassTypeInformation.from(Slice.class); private static final TypeInformation<Slice> SLICE_TYPE = TypeInformation.of(Slice.class);
private final MappingContext<? extends RelationalPersistentEntity<?>, ? extends RelationalPersistentProperty> mappingContext; private final MappingContext<? extends RelationalPersistentEntity<?>, ? extends RelationalPersistentProperty> mappingContext;
private final Optional<Query> query; private final Optional<Query> query;
@@ -91,7 +90,7 @@ public class R2dbcQueryMethod extends QueryMethod {
if (hasParameterOfType(method, Pageable.class)) { if (hasParameterOfType(method, Pageable.class)) {
TypeInformation<?> returnType = ClassTypeInformation.fromReturnTypeOf(method); TypeInformation<?> returnType = TypeInformation.fromReturnTypeOf(method);
boolean multiWrapper = ReactiveWrappers.isMultiValueType(returnType.getType()); boolean multiWrapper = ReactiveWrappers.isMultiValueType(returnType.getType());
boolean singleWrapperWithWrappedPageableResult = ReactiveWrappers.isSingleValueType(returnType.getType()) boolean singleWrapperWithWrappedPageableResult = ReactiveWrappers.isSingleValueType(returnType.getType())

9
spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/AbstractR2dbcRepositoryIntegrationTests.java
View File

@@ -23,8 +23,6 @@ import lombok.Getter;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import lombok.Setter; import lombok.Setter;
import lombok.Value; import lombok.Value;
import org.springframework.data.relational.core.sql.LockMode;
import org.springframework.data.relational.repository.Lock;
import reactor.core.publisher.Flux; import reactor.core.publisher.Flux;
import reactor.core.publisher.Hooks; import reactor.core.publisher.Hooks;
import reactor.core.publisher.Mono; import reactor.core.publisher.Mono;
@@ -39,16 +37,17 @@ import javax.sql.DataSource;
import org.assertj.core.api.Condition; import org.assertj.core.api.Condition;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException; import org.springframework.dao.DataAccessException;
import org.springframework.data.annotation.Id; import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.PersistenceConstructor; import org.springframework.data.annotation.PersistenceCreator;
import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Pageable;
import org.springframework.data.r2dbc.repository.support.R2dbcRepositoryFactory; import org.springframework.data.r2dbc.repository.support.R2dbcRepositoryFactory;
import org.springframework.data.r2dbc.testing.R2dbcIntegrationTestSupport; import org.springframework.data.r2dbc.testing.R2dbcIntegrationTestSupport;
import org.springframework.data.relational.core.mapping.Table; import org.springframework.data.relational.core.mapping.Table;
import org.springframework.data.relational.core.sql.LockMode;
import org.springframework.data.relational.repository.Lock;
import org.springframework.data.repository.NoRepositoryBean; import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.reactive.ReactiveCrudRepository; import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.JdbcTemplate;
@@ -479,7 +478,7 @@ public abstract class AbstractR2dbcRepositoryIntegrationTests extends R2dbcInteg
Integer manual; Integer manual;
boolean flag; boolean flag;
@PersistenceConstructor @PersistenceCreator
LegoSet(Integer id, String name, Integer manual) { LegoSet(Integer id, String name, Integer manual) {
super(id); super(id);
this.name = name; this.name = name;

8
spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/AbstractR2dbcRepositoryWithMixedCaseNamesIntegrationTests.java
View File

@@ -35,7 +35,7 @@ import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException; import org.springframework.dao.DataAccessException;
import org.springframework.data.annotation.Id; import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.PersistenceConstructor; import org.springframework.data.annotation.PersistenceCreator;
import org.springframework.data.r2dbc.testing.R2dbcIntegrationTestSupport; import org.springframework.data.r2dbc.testing.R2dbcIntegrationTestSupport;
import org.springframework.data.relational.core.mapping.Column; import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table; import org.springframework.data.relational.core.mapping.Table;
@@ -126,13 +126,15 @@ public abstract class AbstractR2dbcRepositoryWithMixedCaseNamesIntegrationTests
@NoArgsConstructor @NoArgsConstructor
public static class LegoSet { public static class LegoSet {
@Nullable @Column("Id") @Id Integer id; @Nullable
@Column("Id")
@Id Integer id;
@Column("Name") String name; @Column("Name") String name;
@Column("Manual") Integer manual; @Column("Manual") Integer manual;
@PersistenceConstructor @PersistenceCreator
LegoSet(@Nullable Integer id, String name, Integer manual) { LegoSet(@Nullable Integer id, String name, Integer manual) {
this.id = id; this.id = id;
this.name = name; this.name = name;

7
spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/config/R2dbcRepositoryConfigurationExtensionUnitTests.java
View File

@@ -26,7 +26,7 @@ import org.springframework.core.env.Environment;
import org.springframework.core.env.StandardEnvironment; import org.springframework.core.env.StandardEnvironment;
import org.springframework.core.io.ResourceLoader; import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.StandardAnnotationMetadata; import org.springframework.core.type.AnnotationMetadata;
import org.springframework.data.r2dbc.repository.R2dbcRepository; import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.data.relational.core.mapping.Table; import org.springframework.data.relational.core.mapping.Table;
import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.CrudRepository;
@@ -43,14 +43,13 @@ import org.springframework.data.repository.reactive.ReactiveCrudRepository;
*/ */
class R2dbcRepositoryConfigurationExtensionUnitTests { class R2dbcRepositoryConfigurationExtensionUnitTests {
private final StandardAnnotationMetadata metadata = new StandardAnnotationMetadata(Config.class, true); private final AnnotationMetadata metadata = AnnotationMetadata.introspect(Config.class);
private final ResourceLoader loader = new PathMatchingResourcePatternResolver(); private final ResourceLoader loader = new PathMatchingResourcePatternResolver();
private final Environment environment = new StandardEnvironment(); private final Environment environment = new StandardEnvironment();
private final BeanDefinitionRegistry registry = new DefaultListableBeanFactory(); private final BeanDefinitionRegistry registry = new DefaultListableBeanFactory();
private final RepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource( private final RepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(
metadata, metadata, EnableR2dbcRepositories.class, loader, environment, registry);
EnableR2dbcRepositories.class, loader, environment, registry);
@Test // gh-13 @Test // gh-13
void isStrictMatchIfDomainTypeIsAnnotatedWithDocument() { void isStrictMatchIfDomainTypeIsAnnotatedWithDocument() {

5
spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/testing/ExternalDatabase.java
View File

@@ -85,8 +85,7 @@ public abstract class ExternalDatabase implements BeforeAllCallback {
public void beforeAll(ExtensionContext context) { public void beforeAll(ExtensionContext context) {
if (!checkValidity()) { if (!checkValidity()) {
throw new TestAbortedException( throw new TestAbortedException(String.format("Cannot connect to %s. Skipping tests.", this));
String.format("Cannot connect to %s. Skipping tests.", this));
} }
} }
@@ -134,7 +133,7 @@ public abstract class ExternalDatabase implements BeforeAllCallback {
*/ */
public static ProvidedDatabaseBuilder builder(JdbcDatabaseContainer container) { public static ProvidedDatabaseBuilder builder(JdbcDatabaseContainer container) {
return builder().hostname(container.getContainerIpAddress()) // return builder().hostname(container.getHost()) //
.port(container.getFirstMappedPort()) // .port(container.getFirstMappedPort()) //
.username(container.getUsername()) // .username(container.getUsername()) //
.password(container.getPassword()) // .password(container.getPassword()) //

2
spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/testing/OracleConnectionFactoryProviderWrapper.java
View File

@@ -47,7 +47,7 @@ public class OracleConnectionFactoryProviderWrapper implements ConnectionFactory
try { try {
return (ConnectionFactoryProvider) Class.forName("oracle.r2dbc.impl.OracleConnectionFactoryProviderImpl") return (ConnectionFactoryProvider) Class.forName("oracle.r2dbc.impl.OracleConnectionFactoryProviderImpl")
.newInstance(); .getDeclaredConstructor().newInstance();
} catch (ReflectiveOperationException e) { } catch (ReflectiveOperationException e) {
ReflectionUtils.handleReflectionException(e); ReflectionUtils.handleReflectionException(e);
} }

3
spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/BasicRelationalConverter.java
View File

@@ -38,7 +38,6 @@ import org.springframework.data.mapping.model.ParameterValueProvider;
import org.springframework.data.mapping.model.SimpleTypeHolder; import org.springframework.data.mapping.model.SimpleTypeHolder;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty; import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.util.ClassTypeInformation;
import org.springframework.data.util.TypeInformation; import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Nullable; import org.springframework.lang.Nullable;
import org.springframework.util.Assert; import org.springframework.util.Assert;
@@ -162,7 +161,7 @@ public class BasicRelationalConverter implements RelationalConverter {
if (getConversions().isSimpleType(value.getClass())) { if (getConversions().isSimpleType(value.getClass())) {
if (ClassTypeInformation.OBJECT != type) { if (TypeInformation.OBJECT != type) {
if (conversionService.canConvert(value.getClass(), type.getType())) { if (conversionService.canConvert(value.getClass(), type.getType())) {
value = conversionService.convert(value, type.getType()); value = conversionService.convert(value, type.getType());

11
spring-data-relational/src/test/java/org/springframework/data/relational/core/conversion/BasicRelationalConverterUnitTests.java
View File

@@ -33,7 +33,6 @@ import org.springframework.data.mapping.PersistentPropertyAccessor;
import org.springframework.data.relational.core.mapping.RelationalMappingContext; import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity; import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty; import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.util.ClassTypeInformation;
import org.springframework.data.util.TypeInformation; import org.springframework.data.util.TypeInformation;
/** /**
@@ -78,7 +77,7 @@ class BasicRelationalConverterUnitTests {
@Test // DATAJDBC-235 @Test // DATAJDBC-235
void shouldConvertEnumToString() { void shouldConvertEnumToString() {
Object result = converter.writeValue(MyEnum.ON, ClassTypeInformation.from(String.class)); Object result = converter.writeValue(MyEnum.ON, TypeInformation.of(String.class));
assertThat(result).isEqualTo("ON"); assertThat(result).isEqualTo("ON");
} }
@@ -86,7 +85,7 @@ class BasicRelationalConverterUnitTests {
@Test // DATAJDBC-235 @Test // DATAJDBC-235
void shouldConvertStringToEnum() { void shouldConvertStringToEnum() {
Object result = converter.readValue("OFF", ClassTypeInformation.from(MyEnum.class)); Object result = converter.readValue("OFF", TypeInformation.of(MyEnum.class));
assertThat(result).isEqualTo(MyEnum.OFF); assertThat(result).isEqualTo(MyEnum.OFF);
} }
@@ -94,7 +93,7 @@ class BasicRelationalConverterUnitTests {
@Test // GH-1046 @Test // GH-1046
void shouldConvertArrayElementsToTargetElementType() throws NoSuchMethodException { void shouldConvertArrayElementsToTargetElementType() throws NoSuchMethodException {
TypeInformation<Object> typeInformation = ClassTypeInformation TypeInformation<?> typeInformation = TypeInformation
.fromReturnTypeOf(EntityWithArray.class.getMethod("getFloats")); .fromReturnTypeOf(EntityWithArray.class.getMethod("getFloats"));
Double[] value = { 1.2d, 1.3d, 1.4d }; Double[] value = { 1.2d, 1.3d, 1.4d };
Object result = converter.readValue(value, typeInformation); Object result = converter.readValue(value, typeInformation);
@@ -116,7 +115,7 @@ class BasicRelationalConverterUnitTests {
@Test // DATAJDBC-516 @Test // DATAJDBC-516
void shouldConsiderWriteConverter() { void shouldConsiderWriteConverter() {
Object result = converter.writeValue(new MyValue("hello-world"), ClassTypeInformation.from(MyValue.class)); Object result = converter.writeValue(new MyValue("hello-world"), TypeInformation.of(MyValue.class));
assertThat(result).isEqualTo("hello-world"); assertThat(result).isEqualTo("hello-world");
} }
@@ -124,7 +123,7 @@ class BasicRelationalConverterUnitTests {
@Test // DATAJDBC-516 @Test // DATAJDBC-516
void shouldConsiderReadConverter() { void shouldConsiderReadConverter() {
Object result = converter.readValue("hello-world", ClassTypeInformation.from(MyValue.class)); Object result = converter.readValue("hello-world", TypeInformation.of(MyValue.class));
assertThat(result).isEqualTo(new MyValue("hello-world")); assertThat(result).isEqualTo(new MyValue("hello-world"));
} }