Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit e3a70e7

Browse files
committed
GH-2020 Added SqlTypeResolver abstraction
Signed-off-by: mipo256 <mikhailpolivakha@gmail.com>
1 parent e82befd commit e3a70e7

File tree

20 files changed

+665
-99
lines changed

20 files changed

+665
-99
lines changed

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/DefaultJdbcTypeFactory.java

Lines changed: 0 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -44,25 +44,6 @@ public DefaultJdbcTypeFactory(JdbcOperations operations) {
4444
this(operations, org.springframework.data.jdbc.core.dialect.JdbcArrayColumns.DefaultSupport.INSTANCE);
4545
}
4646

47-
/**
48-
* Creates a new {@link DefaultJdbcTypeFactory}.
49-
*
50-
* @param operations must not be {@literal null}.
51-
* @since 2.3
52-
* @deprecated use
53-
* {@link #DefaultJdbcTypeFactory(JdbcOperations, org.springframework.data.jdbc.core.dialect.JdbcArrayColumns)}
54-
* instead.
55-
*/
56-
@Deprecated(forRemoval = true, since = "3.5")
57-
public DefaultJdbcTypeFactory(JdbcOperations operations, JdbcArrayColumns arrayColumns) {
58-
59-
Assert.notNull(operations, "JdbcOperations must not be null");
60-
Assert.notNull(arrayColumns, "JdbcArrayColumns must not be null");
61-
62-
this.operations = operations;
63-
this.arrayColumns = arrayColumns;
64-
}
65-
6647
/**
6748
* Creates a new {@link DefaultJdbcTypeFactory}.
6849
*

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/DelegatingDataAccessStrategy.java

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -45,6 +45,10 @@ public class DelegatingDataAccessStrategy implements DataAccessStrategy {
4545

4646
private DataAccessStrategy delegate;
4747

48+
/**
49+
* @deprecated please, use {@link DelegatingDataAccessStrategy#DelegatingDataAccessStrategy(DataAccessStrategy)} instead
50+
*/
51+
@Deprecated(forRemoval = true, since = "4.0")
4852
public DelegatingDataAccessStrategy() {}
4953

5054
public DelegatingDataAccessStrategy(DataAccessStrategy delegate) {

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/dialect/JdbcDialect.java

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,8 @@
1616
package org.springframework.data.jdbc.core.dialect;
1717

1818
import org.springframework.data.relational.core.dialect.Dialect;
19+
import org.springframework.data.jdbc.core.dialect.SqlTypeResolver;
20+
import org.springframework.data.jdbc.core.dialect.DefaultSqlTypeResolver;
1921

2022
/**
2123
* {@link org.springframework.data.relational.core.dialect.ArrayColumns} that offer JDBC specific functionality.
@@ -37,4 +39,12 @@ default JdbcArrayColumns getArraySupport() {
3739
return JdbcArrayColumns.Unsupported.INSTANCE;
3840
}
3941

42+
/**
43+
* Returns a {@link SqlTypeResolver} of this dialect.
44+
*
45+
* @since 4.0
46+
*/
47+
default SqlTypeResolver getSqlTypeResolver() {
48+
return DefaultSqlTypeResolver.INSTANCE;
49+
}
4050
}

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/JdbcParameters.java

Lines changed: 42 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -21,28 +21,47 @@
2121
import org.springframework.core.MethodParameter;
2222
import org.springframework.data.jdbc.core.convert.JdbcColumnTypes;
2323
import org.springframework.data.jdbc.support.JdbcUtil;
24+
import org.springframework.data.jdbc.core.dialect.DefaultSqlTypeResolver;
25+
import org.springframework.data.jdbc.core.dialect.SqlTypeResolver;
2426
import org.springframework.data.relational.repository.query.RelationalParameters;
2527
import org.springframework.data.repository.query.Parameter;
2628
import org.springframework.data.repository.query.ParametersSource;
2729
import org.springframework.data.util.Lazy;
2830
import org.springframework.data.util.TypeInformation;
31+
import org.springframework.util.Assert;
2932

3033
/**
3134
* Custom extension of {@link RelationalParameters}.
3235
*
3336
* @author Mark Paluch
37+
* @author Mikhail Polivakha
3438
* @since 3.2.6
3539
*/
3640
public class JdbcParameters extends RelationalParameters {
3741

3842
/**
39-
* Creates a new {@link JdbcParameters} instance from the given {@link ParametersSource}.
43+
* Creates a new {@link JdbcParameters} instance from the given {@link ParametersSource}. Uses the {@link DefaultSqlTypeResolver}.
4044
*
4145
* @param parametersSource must not be {@literal null}.
4246
*/
4347
public JdbcParameters(ParametersSource parametersSource) {
4448
super(parametersSource,
45-
methodParameter -> new JdbcParameter(methodParameter, parametersSource.getDomainTypeInformation()));
49+
methodParameter -> new JdbcParameter(methodParameter, parametersSource.getDomainTypeInformation(),
50+
DefaultSqlTypeResolver.INSTANCE));
51+
}
52+
53+
/**
54+
* Creates a new {@link JdbcParameters} instance from the given {@link ParametersSource} and given {@link SqlTypeResolver}.
55+
*
56+
* @param parametersSource must not be {@literal null}.
57+
* @param sqlTypeResolver must not be {@literal null}.
58+
*/
59+
public JdbcParameters(ParametersSource parametersSource, SqlTypeResolver sqlTypeResolver) {
60+
super(parametersSource,
61+
methodParameter -> new JdbcParameter(methodParameter, parametersSource.getDomainTypeInformation(), sqlTypeResolver));
62+
63+
Assert.notNull(sqlTypeResolver, "SqlTypeResolver must not be null");
64+
Assert.notNull(parametersSource, "ParametersSource must not be null");
4665
}
4766

4867
@SuppressWarnings({ "rawtypes", "unchecked" })
@@ -69,27 +88,42 @@ protected JdbcParameters createFrom(List<RelationalParameter> parameters) {
6988
*/
7089
public static class JdbcParameter extends RelationalParameter {
7190

72-
private final SQLType sqlType;
91+
private final Lazy<SQLType> sqlType;
7392
private final Lazy<SQLType> actualSqlType;
7493

7594
/**
7695
* Creates a new {@link RelationalParameter}.
7796
*
7897
* @param parameter must not be {@literal null}.
7998
*/
80-
JdbcParameter(MethodParameter parameter, TypeInformation<?> domainType) {
99+
JdbcParameter(MethodParameter parameter, TypeInformation<?> domainType, SqlTypeResolversqlTypeResolver) {
81100
super(parameter, domainType);
82101

83102
TypeInformation<?> typeInformation = getTypeInformation();
84103

85-
sqlType = JdbcUtil.targetSqlTypeFor(JdbcColumnTypes.INSTANCE.resolvePrimitiveType(typeInformation.getType()));
104+
sqlType = Lazy.of(() -> {
105+
SQLType resolvedSqlType = sqlTypeResolver.resolveSqlType(this);
106+
107+
if (resolvedSqlType == null) {
108+
return JdbcUtil.targetSqlTypeFor(JdbcColumnTypes.INSTANCE.resolvePrimitiveType(typeInformation.getType()));
109+
} else {
110+
return resolvedSqlType;
111+
}
112+
});
113+
114+
actualSqlType = Lazy.of(() -> {
115+
SQLType resolvedActualSqlType = sqlTypeResolver.resolveActualSqlType(this);
86116

87-
actualSqlType = Lazy.of(() -> JdbcUtil
88-
.targetSqlTypeFor(JdbcColumnTypes.INSTANCE.resolvePrimitiveType(typeInformation.getActualType().getType())));
117+
if (resolvedActualSqlType == null) {
118+
return JdbcUtil.targetSqlTypeFor(JdbcColumnTypes.INSTANCE.resolvePrimitiveType(typeInformation.getActualType().getType()));
119+
} else {
120+
return resolvedActualSqlType;
121+
}
122+
});
89123
}
90124

91125
public SQLType getSqlType() {
92-
return sqlType;
126+
return sqlType.get();
93127
}
94128

95129
public SQLType getActualSqlType() {

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/JdbcQueryMethod.java

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,8 @@
2424
import org.springframework.core.annotation.AnnotationUtils;
2525
import org.springframework.data.mapping.context.MappingContext;
2626
import org.springframework.data.projection.ProjectionFactory;
27+
import org.springframework.data.jdbc.core.dialect.DefaultSqlTypeResolver;
28+
import org.springframework.data.jdbc.core.dialect.SqlTypeResolver;
2729
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
2830
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
2931
import org.springframework.data.relational.repository.Lock;
@@ -34,6 +36,7 @@
3436
import org.springframework.data.repository.query.Parameters;
3537
import org.springframework.data.repository.query.ParametersSource;
3638
import org.springframework.data.repository.query.QueryMethod;
39+
import org.springframework.data.util.Lazy;
3740
import org.springframework.jdbc.core.ResultSetExtractor;
3841
import org.springframework.jdbc.core.RowMapper;
3942
import org.springframework.lang.Nullable;
@@ -53,6 +56,7 @@
5356
* @author Diego Krupitza
5457
* @author Mark Paluch
5558
* @author Daeho Kwon
59+
* @author Mikhail Polivakha
5660
*/
5761
public class JdbcQueryMethod extends QueryMethod {
5862

@@ -67,8 +71,15 @@ public class JdbcQueryMethod extends QueryMethod {
6771
public JdbcQueryMethod(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
6872
NamedQueries namedQueries,
6973
MappingContext<? extends RelationalPersistentEntity<?>, ? extends RelationalPersistentProperty> mappingContext) {
74+
this(method, metadata, factory, namedQueries, mappingContext, DefaultSqlTypeResolver.INSTANCE);
75+
}
76+
77+
public JdbcQueryMethod(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
78+
NamedQueries namedQueries,
79+
MappingContext<? extends RelationalPersistentEntity<?>, ? extends RelationalPersistentProperty> mappingContext,
80+
SqlTypeResolver sqlTypeResolver) {
7081

71-
super(method, metadata, factory, JdbcParameters::new);
82+
super(method, metadata, factory, parametersSource -> newJdbcParameters(parametersSource, sqlTypeResolver));
7283
this.namedQueries = namedQueries;
7384
this.method = method;
7485
this.mappingContext = mappingContext;

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/StringBasedJdbcQuery.java

Lines changed: 20 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -85,13 +85,13 @@ public class StringBasedJdbcQuery extends AbstractJdbcQuery {
8585

8686
/**
8787
* Creates a new {@link StringBasedJdbcQuery} for the given {@link JdbcQueryMethod}, {@link RelationalMappingContext}
88-
* and {@link org.springframework.data.jdbc.repository.query.RowMapperFactory}.
88+
* and {@link RowMapperFactory}.
8989
*
90-
* @param queryMethod must not be {@literal null}.
91-
* @param operations must not be {@literal null}.
90+
* @param queryMethod must not be {@literal null}.
91+
* @param operations must not be {@literal null}.
9292
* @param rowMapperFactory must not be {@literal null}.
93-
* @param converter must not be {@literal null}.
94-
* @param delegate must not be {@literal null}.
93+
* @param converter must not be {@literal null}.
94+
* @param delegate must not be {@literal null}.
9595
* @since 3.4
9696
*/
9797
public StringBasedJdbcQuery(JdbcQueryMethod queryMethod, NamedParameterJdbcOperations operations,
@@ -104,12 +104,12 @@ public StringBasedJdbcQuery(JdbcQueryMethod queryMethod, NamedParameterJdbcOpera
104104
* Creates a new {@link StringBasedJdbcQuery} for the given {@link JdbcQueryMethod}, {@link RelationalMappingContext}
105105
* and {@link org.springframework.data.jdbc.repository.query.RowMapperFactory}.
106106
*
107-
* @param query must not be {@literal null} or empty.
108-
* @param queryMethod must not be {@literal null}.
109-
* @param operations must not be {@literal null}.
107+
* @param query must not be {@literal null} or empty.
108+
* @param queryMethod must not be {@literal null}.
109+
* @param operations must not be {@literal null}.
110110
* @param rowMapperFactory must not be {@literal null}.
111-
* @param converter must not be {@literal null}.
112-
* @param delegate must not be {@literal null}.
111+
* @param converter must not be {@literal null}.
112+
* @param delegate must not be {@literal null}.
113113
* @since 3.4
114114
*/
115115
public StringBasedJdbcQuery(String query, JdbcQueryMethod queryMethod, NamedParameterJdbcOperations operations,
@@ -347,7 +347,8 @@ private static boolean isUnconfigured(@Nullable Class<?> configuredClass, Class<
347347
}
348348

349349
@Deprecated(since = "3.4")
350-
public void setBeanFactory(BeanFactory beanFactory) {}
350+
public void setBeanFactory(BeanFactory beanFactory) {
351+
}
351352

352353
class CachedRowMapperFactory {
353354

@@ -406,19 +407,20 @@ public CachedResultSetExtractorFactory(Supplier<RowMapper<?>> resultSetExtractor
406407
String resultSetExtractorRef = getQueryMethod().getResultSetExtractorRef();
407408
Class<? extends ResultSetExtractor> resultSetExtractorClass = getQueryMethod().getResultSetExtractorClass();
408409

409-
if (!ObjectUtils.isEmpty(resultSetExtractorRef)
410-
&& !isUnconfigured(resultSetExtractorClass, ResultSetExtractor.class)) {
410+
if (!ObjectUtils.isEmpty(resultSetExtractorRef) && !isUnconfigured(resultSetExtractorClass,
411+
ResultSetExtractor.class)) {
411412
throw new IllegalArgumentException(
412413
"Invalid ResultSetExtractor configuration. Configure either one but not both via @Query(resultSetExtractorRef = ..., resultSetExtractorClass = ...) for query method "
413414
+ getQueryMethod());
414415
}
415416

416-
this.configuredResultSetExtractor = !ObjectUtils.isEmpty(resultSetExtractorRef)
417-
|| !isUnconfigured(resultSetExtractorClass, ResultSetExtractor.class);
417+
this.configuredResultSetExtractor =
418+
!ObjectUtils.isEmpty(resultSetExtractorRef) || !isUnconfigured(resultSetExtractorClass,
419+
ResultSetExtractor.class);
418420

419-
this.rowMapperConstructor = resultSetExtractorClass != null
420-
? ClassUtils.getConstructorIfAvailable(resultSetExtractorClass, RowMapper.class)
421-
: null;
421+
this.rowMapperConstructor = resultSetExtractorClass != null ?
422+
ClassUtils.getConstructorIfAvailable(resultSetExtractorClass, RowMapper.class) :
423+
null;
422424
this.constructor = resultSetExtractorClass != null ? findPrimaryConstructor(resultSetExtractorClass) : null;
423425
this.resultSetExtractorFactory = rowMapper -> {
424426

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategy.java

Lines changed: 59 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323
import org.springframework.context.ApplicationEventPublisher;
2424
import org.springframework.data.jdbc.core.convert.JdbcConverter;
2525
import org.springframework.data.jdbc.core.convert.QueryMappingConfiguration;
26+
import org.springframework.data.jdbc.core.dialect.JdbcDialect;
2627
import org.springframework.data.jdbc.repository.query.DefaultRowMapperFactory;
2728
import org.springframework.data.jdbc.repository.query.JdbcQueryMethod;
2829
import org.springframework.data.jdbc.repository.query.PartTreeJdbcQuery;
@@ -69,7 +70,7 @@ abstract class JdbcQueryLookupStrategy extends RelationalQueryLookupStrategy {
6970
protected final ValueExpressionDelegate delegate;
7071

7172
JdbcQueryLookupStrategy(ApplicationEventPublisher publisher, @Nullable EntityCallbacks callbacks,
72-
RelationalMappingContext context, JdbcConverter converter, Dialect dialect,
73+
RelationalMappingContext context, JdbcConverter converter, JdbcDialect dialect,
7374
QueryMappingConfiguration queryMappingConfiguration, NamedParameterJdbcOperations operations,
7475
ValueExpressionDelegate delegate) {
7576

@@ -105,7 +106,7 @@ static class CreateQueryLookupStrategy extends JdbcQueryLookupStrategy {
105106
private final RowMapperFactory rowMapperFactory;
106107

107108
CreateQueryLookupStrategy(ApplicationEventPublisher publisher, @Nullable EntityCallbacks callbacks,
108-
RelationalMappingContext context, JdbcConverter converter, Dialect dialect,
109+
RelationalMappingContext context, JdbcConverter converter, JdbcDialect dialect,
109110
QueryMappingConfiguration queryMappingConfiguration, NamedParameterJdbcOperations operations,
110111
ValueExpressionDelegate delegate) {
111112

@@ -138,7 +139,7 @@ static class DeclaredQueryLookupStrategy extends JdbcQueryLookupStrategy {
138139
private final RowMapperFactory rowMapperFactory;
139140

140141
DeclaredQueryLookupStrategy(ApplicationEventPublisher publisher, @Nullable EntityCallbacks callbacks,
141-
RelationalMappingContext context, JdbcConverter converter, Dialect dialect,
142+
RelationalMappingContext context, JdbcConverter converter, JdbcDialect dialect,
142143
QueryMappingConfiguration queryMappingConfiguration, NamedParameterJdbcOperations operations,
143144
@Nullable BeanFactory beanfactory, ValueExpressionDelegate delegate) {
144145
super(publisher, callbacks, context, converter, dialect, queryMappingConfiguration, operations, delegate);
@@ -191,7 +192,7 @@ static class CreateIfNotFoundQueryLookupStrategy extends JdbcQueryLookupStrategy
191192
* @param lookupStrategy must not be {@literal null}.
192193
*/
193194
CreateIfNotFoundQueryLookupStrategy(ApplicationEventPublisher publisher, @Nullable EntityCallbacks callbacks,
194-
RelationalMappingContext context, JdbcConverter converter, Dialect dialect,
195+
RelationalMappingContext context, JdbcConverter converter, JdbcDialect dialect,
195196
QueryMappingConfiguration queryMappingConfiguration, NamedParameterJdbcOperations operations,
196197
CreateQueryLookupStrategy createStrategy, DeclaredQueryLookupStrategy lookupStrategy,
197198
ValueExpressionDelegate delegate) {
@@ -222,7 +223,12 @@ public RepositoryQuery resolveQuery(Method method, RepositoryMetadata repository
222223
*/
223224
JdbcQueryMethod getJdbcQueryMethod(Method method, RepositoryMetadata repositoryMetadata,
224225
ProjectionFactory projectionFactory, NamedQueries namedQueries) {
225-
return new JdbcQueryMethod(method, repositoryMetadata, projectionFactory, namedQueries, getMappingContext());
226+
return new JdbcQueryMethod(method, repositoryMetadata, projectionFactory, namedQueries, getMappingContext(), getDialect().getSqlTypeResolver());
227+
}
228+
229+
@Override
230+
public JdbcDialect getDialect() {
231+
return (JdbcDialect) super.getDialect();
226232
}
227233

228234
/**
@@ -238,7 +244,9 @@ JdbcQueryMethod getJdbcQueryMethod(Method method, RepositoryMetadata repositoryM
238244
* @param queryMappingConfiguration must not be {@literal null}
239245
* @param operations must not be {@literal null}
240246
* @param beanFactory may be {@literal null}
247+
* @deprecated please, use {@link #create(Key, ApplicationEventPublisher, EntityCallbacks, RelationalMappingContext, JdbcConverter, JdbcDialect, QueryMappingConfiguration, NamedParameterJdbcOperations, BeanFactory, ValueExpressionDelegate)}
241248
*/
249+
@Deprecated(forRemoval = true, since = "4.0")
242250
public static QueryLookupStrategy create(@Nullable Key key, ApplicationEventPublisher publisher,
243251
@Nullable EntityCallbacks callbacks, RelationalMappingContext context, JdbcConverter converter, Dialect dialect,
244252
QueryMappingConfiguration queryMappingConfiguration, NamedParameterJdbcOperations operations,
@@ -250,6 +258,52 @@ public static QueryLookupStrategy create(@Nullable Key key, ApplicationEventPubl
250258
Assert.notNull(queryMappingConfiguration, "QueryMappingConfiguration must not be null");
251259
Assert.notNull(operations, "NamedParameterJdbcOperations must not be null");
252260
Assert.notNull(delegate, "ValueExpressionDelegate must not be null");
261+
Assert.state(dialect instanceof JdbcDialect, "Dialect must be an instance of the JdbcDialect");
262+
263+
CreateQueryLookupStrategy createQueryLookupStrategy = new CreateQueryLookupStrategy(publisher, callbacks, context,
264+
converter, (JdbcDialect) dialect, queryMappingConfiguration, operations, delegate);
265+
266+
DeclaredQueryLookupStrategy declaredQueryLookupStrategy = new DeclaredQueryLookupStrategy(publisher, callbacks,
267+
context, converter, (JdbcDialect) dialect, queryMappingConfiguration, operations, beanFactory, delegate);
268+
269+
Key keyToUse = key != null ? key : Key.CREATE_IF_NOT_FOUND;
270+
271+
LOG.debug(String.format("Using the queryLookupStrategy %s", keyToUse));
272+
273+
return switch (keyToUse) {
274+
case CREATE -> createQueryLookupStrategy;
275+
case USE_DECLARED_QUERY -> declaredQueryLookupStrategy;
276+
case CREATE_IF_NOT_FOUND ->
277+
new CreateIfNotFoundQueryLookupStrategy(publisher, callbacks, context, converter, (JdbcDialect) dialect,
278+
queryMappingConfiguration, operations, createQueryLookupStrategy, declaredQueryLookupStrategy, delegate);
279+
};
280+
}
281+
282+
/**
283+
* Creates a {@link QueryLookupStrategy} based on the provided
284+
* {@link org.springframework.data.repository.query.QueryLookupStrategy.Key}.
285+
*
286+
* @param key the key that decides what {@link QueryLookupStrategy} shozld be used.
287+
* @param publisher must not be {@literal null}
288+
* @param callbacks may be {@literal null}
289+
* @param context must not be {@literal null}
290+
* @param converter must not be {@literal null}
291+
* @param dialect must not be {@literal null}
292+
* @param queryMappingConfiguration must not be {@literal null}
293+
* @param operations must not be {@literal null}
294+
* @param beanFactory may be {@literal null}
295+
*/
296+
public static QueryLookupStrategy create(@Nullable Key key, ApplicationEventPublisher publisher,
297+
@Nullable EntityCallbacks callbacks, RelationalMappingContext context, JdbcConverter converter, JdbcDialect dialect,
298+
QueryMappingConfiguration queryMappingConfiguration, NamedParameterJdbcOperations operations,
299+
@Nullable BeanFactory beanFactory, ValueExpressionDelegate delegate) {
300+
Assert.notNull(publisher, "ApplicationEventPublisher must not be null");
301+
Assert.notNull(context, "RelationalMappingContextPublisher must not be null");
302+
Assert.notNull(converter, "JdbcConverter must not be null");
303+
Assert.notNull(dialect, "Dialect must not be null");
304+
Assert.notNull(queryMappingConfiguration, "QueryMappingConfiguration must not be null");
305+
Assert.notNull(operations, "NamedParameterJdbcOperations must not be null");
306+
Assert.notNull(delegate, "ValueExpressionDelegate must not be null");
253307

254308
CreateQueryLookupStrategy createQueryLookupStrategy = new CreateQueryLookupStrategy(publisher, callbacks, context,
255309
converter, dialect, queryMappingConfiguration, operations, delegate);

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /