GitHub-Spring
/
spring-data-mongodb
mirror of https://github.com/spring-projects/spring-data-mongodb.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Polishing. 

Reformat code. Use existing SimpleTypeHolder instead of static MongoSimpleTypes.

See: #5027
Original pull request: #5038
pull/5040/head
Mark Paluch 4 months ago
parent
00ab16f92e
commit
46ece81d00
No known key found for this signature in database
GPG Key ID: 55BC6374BAA9D973
12 changed files with 119 additions and 132 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 60
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java
  2. 37
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AggregationBlocks.java
  3. 3
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotPlaceholders.java
  4. 25
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotQueryCreator.java
  5. 4
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotStringQuery.java
  6. 1
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoAotRepositoryFragmentSupport.java
  7. 9
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoCodeBlocks.java
  8. 31
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoRepositoryContributor.java
  9. 1
      spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/Snippet.java
  10. 40
      spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java

60
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java
Unescape View File

@ -111,11 +111,9 @@ import org.springframework.data.mongodb.core.query.UpdateDefinition.ArrayFilter;
import org.springframework.data.mongodb.core.timeseries.Granularity; import org.springframework.data.mongodb.core.timeseries.Granularity;
import org.springframework.data.mongodb.core.validation.Validator; import org.springframework.data.mongodb.core.validation.Validator;
import org.springframework.data.projection.EntityProjection; import org.springframework.data.projection.EntityProjection;
import org.springframework.data.projection.ProjectionFactory;
import org.springframework.data.util.CloseableIterator; import org.springframework.data.util.CloseableIterator;
import org.springframework.data.util.Lazy; import org.springframework.data.util.Lazy;
import org.springframework.data.util.Optionals; import org.springframework.data.util.Optionals;
import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Contract; import org.springframework.lang.Contract;
import org.springframework.util.Assert; import org.springframework.util.Assert;
import org.springframework.util.ClassUtils; import org.springframework.util.ClassUtils;
@ -523,8 +521,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
DocumentCallback<R> resultReader = getResultReader(projection, collectionName, resultConverter); DocumentCallback<R> resultReader = getResultReader(projection, collectionName, resultConverter);
return new CloseableIterableCursorAdapter<>(cursor, exceptionTranslator, return new CloseableIterableCursorAdapter<>(cursor, exceptionTranslator, resultReader).stream();
resultReader).stream();
}); });
} }
@ -1183,11 +1180,12 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
@Override @Override
public <S, T> @Nullable T findAndReplace(Query query, S replacement, FindAndReplaceOptions options, public <S, T> @Nullable T findAndReplace(Query query, S replacement, FindAndReplaceOptions options,
Class<S> entityType, String collectionName, Class<T> resultType) { Class<S> entityType, String collectionName, Class<T> resultType) {
return findAndReplace(query, replacement, options, entityType, collectionName, resultType, QueryResultConverter.entity()); return findAndReplace(query, replacement, options, entityType, collectionName, resultType,
QueryResultConverter.entity());
} }
<S, T, R> @Nullable R findAndReplace(Query query, S replacement, FindAndReplaceOptions options, <S, T, R> @Nullable R findAndReplace(Query query, S replacement, FindAndReplaceOptions options, Class<S> entityType,
Class<S> entityType, String collectionName, Class<T> resultType, QueryResultConverter<? super T, ? extends R> resultConverter) { String collectionName, Class<T> resultType, QueryResultConverter<? super T, ? extends R> resultConverter) {
Assert.notNull(query, "Query must not be null"); Assert.notNull(query, "Query must not be null");
Assert.notNull(replacement, "Replacement must not be null"); Assert.notNull(replacement, "Replacement must not be null");
@ -1215,7 +1213,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
maybeCallBeforeSave(replacement, mappedReplacement, collectionName); maybeCallBeforeSave(replacement, mappedReplacement, collectionName);
R saved = doFindAndReplace(collectionPreparer, collectionName, mappedQuery, mappedFields, mappedSort, R saved = doFindAndReplace(collectionPreparer, collectionName, mappedQuery, mappedFields, mappedSort,
queryContext.getCollation(entityType).orElse(null), entityType, mappedReplacement, options, projection, resultConverter); queryContext.getCollation(entityType).orElse(null), entityType, mappedReplacement, options, projection,
resultConverter);
if (saved != null) { if (saved != null) {
maybeEmitEvent(new AfterSaveEvent<>(saved, mappedReplacement, collectionName)); maybeEmitEvent(new AfterSaveEvent<>(saved, mappedReplacement, collectionName));
@ -2221,8 +2220,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
} }
}; };
List<T> result = doFind(collectionName, createDelegate(query), query.getQueryObject(), query.getFieldsObject(), entityClass, List<T> result = doFind(collectionName, createDelegate(query), query.getQueryObject(), query.getFieldsObject(),
new QueryCursorPreparer(query, entityClass), callback); entityClass, new QueryCursorPreparer(query, entityClass), callback);
if (!CollectionUtils.isEmpty(result)) { if (!CollectionUtils.isEmpty(result)) {
@ -2278,8 +2277,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
if (aggregation instanceof TypedAggregation<?> ta && outputType.isInterface()) { if (aggregation instanceof TypedAggregation<?> ta && outputType.isInterface()) {
EntityProjection<T, ?> projection = operations.introspectProjection(outputType, ta.getInputType()); EntityProjection<T, ?> projection = operations.introspectProjection(outputType, ta.getInputType());
ProjectingReadCallback cb = new ProjectingReadCallback(mongoConverter, projection, collectionName); ProjectingReadCallback cb = new ProjectingReadCallback(mongoConverter, projection, collectionName);
callback = new QueryResultConverterCallback<>(resultConverter, callback = new QueryResultConverterCallback<>(resultConverter, cb);
cb);
} else { } else {
callback = new QueryResultConverterCallback<>(resultConverter, callback = new QueryResultConverterCallback<>(resultConverter,
@ -2370,8 +2368,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
@SuppressWarnings({ "ConstantConditions", "NullAway" }) @SuppressWarnings({ "ConstantConditions", "NullAway" })
<T, O> Stream<O> doAggregateStream(Aggregation aggregation, String collectionName, Class<T> outputType, <T, O> Stream<O> doAggregateStream(Aggregation aggregation, String collectionName, Class<T> outputType,
QueryResultConverter<? super T, ? extends O> resultConverter, QueryResultConverter<? super T, ? extends O> resultConverter, @Nullable AggregationOperationContext context) {
@Nullable AggregationOperationContext context) {
Assert.notNull(aggregation, "Aggregation pipeline must not be null"); Assert.notNull(aggregation, "Aggregation pipeline must not be null");
Assert.hasText(collectionName, "Collection name must not be null or empty"); Assert.hasText(collectionName, "Collection name must not be null or empty");
@ -2649,9 +2646,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
* @return the converted object or {@literal null} if none exists. * @return the converted object or {@literal null} if none exists.
*/ */
@Nullable @Nullable
protected <T> T doFindOne(String collectionName, protected <T> T doFindOne(String collectionName, CollectionPreparer<MongoCollection<Document>> collectionPreparer,
CollectionPreparer<MongoCollection<Document>> collectionPreparer, Document query, Document fields, Document query, Document fields, Class<T> entityClass) {
Class<T> entityClass) {
return doFindOne(collectionName, collectionPreparer, query, fields, CursorPreparer.NO_OP_PREPARER, entityClass); return doFindOne(collectionName, collectionPreparer, query, fields, CursorPreparer.NO_OP_PREPARER, entityClass);
} }
@ -2670,9 +2666,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
*/ */
@Nullable @Nullable
@SuppressWarnings("ConstantConditions") @SuppressWarnings("ConstantConditions")
protected <T> T doFindOne(String collectionName, protected <T> T doFindOne(String collectionName, CollectionPreparer<MongoCollection<Document>> collectionPreparer,
CollectionPreparer<MongoCollection<Document>> collectionPreparer, Document query, Document fields, Document query, Document fields, CursorPreparer preparer, Class<T> entityClass) {
CursorPreparer preparer, Class<T> entityClass) {
MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(entityClass); MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(entityClass);
@ -2870,9 +2865,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
@SuppressWarnings("ConstantConditions") @SuppressWarnings("ConstantConditions")
<S, T> @Nullable T doFindAndModify(CollectionPreparer<MongoCollection<Document>> collectionPreparer, <S, T> @Nullable T doFindAndModify(CollectionPreparer<MongoCollection<Document>> collectionPreparer,
String collectionName, String collectionName, Document query, @Nullable Document fields, @Nullable Document sort, Class<S> entityClass,
Document query, @Nullable Document fields, @Nullable Document sort, Class<S> entityClass, UpdateDefinition update, UpdateDefinition update, @Nullable FindAndModifyOptions options,
@Nullable FindAndModifyOptions options, QueryResultConverter<? super S, ? extends T> resultConverter) { QueryResultConverter<? super S, ? extends T> resultConverter) {
if (options == null) { if (options == null) {
options = new FindAndModifyOptions(); options = new FindAndModifyOptions();
@ -2894,7 +2889,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
serializeToJsonSafely(mappedUpdate), collectionName)); serializeToJsonSafely(mappedUpdate), collectionName));
} }
DocumentCallback<T> callback = getResultReader(EntityProjection.nonProjecting(entityClass), collectionName, resultConverter); DocumentCallback<T> callback = getResultReader(EntityProjection.nonProjecting(entityClass), collectionName,
resultConverter);
return executeFindOneInternal( return executeFindOneInternal(
new FindAndModifyCallback(collectionPreparer, mappedQuery, fields, sort, mappedUpdate, new FindAndModifyCallback(collectionPreparer, mappedQuery, fields, sort, mappedUpdate,
@ -2919,8 +2915,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
*/ */
@Nullable @Nullable
protected <S, T> T doFindAndReplace(CollectionPreparer<MongoCollection<Document>> collectionPreparer, protected <S, T> T doFindAndReplace(CollectionPreparer<MongoCollection<Document>> collectionPreparer,
String collectionName, String collectionName, Document mappedQuery, Document mappedFields, Document mappedSort,
Document mappedQuery, Document mappedFields, Document mappedSort,
com.mongodb.client.model.@Nullable Collation collation, Class<S> entityType, Document replacement, com.mongodb.client.model.@Nullable Collation collation, Class<S> entityType, Document replacement,
FindAndReplaceOptions options, Class<T> resultType) { FindAndReplaceOptions options, Class<T> resultType) {
@ -2963,10 +2958,10 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
*/ */
@Nullable @Nullable
private <S, T, R> R doFindAndReplace(CollectionPreparer<MongoCollection<Document>> collectionPreparer, private <S, T, R> R doFindAndReplace(CollectionPreparer<MongoCollection<Document>> collectionPreparer,
String collectionName, String collectionName, Document mappedQuery, Document mappedFields, Document mappedSort,
Document mappedQuery, Document mappedFields, Document mappedSort,
com.mongodb.client.model.@Nullable Collation collation, Class<T> entityType, Document replacement, com.mongodb.client.model.@Nullable Collation collation, Class<T> entityType, Document replacement,
FindAndReplaceOptions options, EntityProjection<S, T> projection, QueryResultConverter<? super S, ? extends R> resultConverter) { FindAndReplaceOptions options, EntityProjection<S, T> projection,
QueryResultConverter<? super S, ? extends R> resultConverter) {
if (LOGGER.isDebugEnabled()) { if (LOGGER.isDebugEnabled()) {
LOGGER LOGGER
@ -2979,8 +2974,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
DocumentCallback<R> callback = getResultReader(projection, collectionName, resultConverter); DocumentCallback<R> callback = getResultReader(projection, collectionName, resultConverter);
return executeFindOneInternal(new FindAndReplaceCallback(collectionPreparer, mappedQuery, mappedFields, mappedSort, return executeFindOneInternal(new FindAndReplaceCallback(collectionPreparer, mappedQuery, mappedFields, mappedSort,
replacement, collation, options),callback, replacement, collation, options), callback, collectionName);
collectionName);
} }
@SuppressWarnings("NullAway") @SuppressWarnings("NullAway")
@ -3158,8 +3152,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware,
return getMappedSortObject(sortObject, mappingContext.getPersistentEntity(type)); return getMappedSortObject(sortObject, mappingContext.getPersistentEntity(type));
} }
private @Nullable Document getMappedSortObject(@Nullable Document sortObject,
private @Nullable Document getMappedSortObject(@Nullable Document sortObject, @Nullable MongoPersistentEntity<?> entity) { @Nullable MongoPersistentEntity<?> entity) {
if (ObjectUtils.isEmpty(sortObject)) { if (ObjectUtils.isEmpty(sortObject)) {
return null; return null;

37
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AggregationBlocks.java
Unescape View File

@ -22,10 +22,12 @@ import java.util.stream.Stream;
import org.bson.Document; import org.bson.Document;
import org.jspecify.annotations.NullUnmarked; import org.jspecify.annotations.NullUnmarked;
import org.springframework.core.ResolvableType; import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.MergedAnnotation; import org.springframework.core.annotation.MergedAnnotation;
import org.springframework.data.domain.SliceImpl; import org.springframework.data.domain.SliceImpl;
import org.springframework.data.domain.Sort.Order; import org.springframework.data.domain.Sort.Order;
import org.springframework.data.mapping.model.SimpleTypeHolder;
import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.Aggregation; import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationOperation; import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
@ -33,7 +35,6 @@ import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
import org.springframework.data.mongodb.core.aggregation.AggregationPipeline; import org.springframework.data.mongodb.core.aggregation.AggregationPipeline;
import org.springframework.data.mongodb.core.aggregation.AggregationResults; import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.TypedAggregation; import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
import org.springframework.data.mongodb.core.mapping.MongoSimpleTypes;
import org.springframework.data.mongodb.core.query.Collation; import org.springframework.data.mongodb.core.query.Collation;
import org.springframework.data.mongodb.repository.Hint; import org.springframework.data.mongodb.repository.Hint;
import org.springframework.data.mongodb.repository.ReadPreference; import org.springframework.data.mongodb.repository.ReadPreference;
@ -58,12 +59,15 @@ class AggregationBlocks {
static class AggregationExecutionCodeBlockBuilder { static class AggregationExecutionCodeBlockBuilder {
private final AotQueryMethodGenerationContext context; private final AotQueryMethodGenerationContext context;
private final SimpleTypeHolder simpleTypeHolder;
private final MongoQueryMethod queryMethod; private final MongoQueryMethod queryMethod;
private String aggregationVariableName; private String aggregationVariableName;
AggregationExecutionCodeBlockBuilder(AotQueryMethodGenerationContext context, MongoQueryMethod queryMethod) { AggregationExecutionCodeBlockBuilder(AotQueryMethodGenerationContext context, SimpleTypeHolder simpleTypeHolder,
MongoQueryMethod queryMethod) {
this.context = context; this.context = context;
this.simpleTypeHolder = simpleTypeHolder;
this.queryMethod = queryMethod; this.queryMethod = queryMethod;
} }
@ -80,7 +84,7 @@ class AggregationBlocks {
builder.add("\n"); builder.add("\n");
Class<?> outputType = getOutputType(queryMethod); Class<?> outputType = getOutputType(simpleTypeHolder, queryMethod);
if (ReflectionUtils.isVoid(queryMethod.getReturnedObjectType())) { if (ReflectionUtils.isVoid(queryMethod.getReturnedObjectType())) {
builder.addStatement("$L.aggregate($L, $T.class)", mongoOpsRef, aggregationVariableName, outputType); builder.addStatement("$L.aggregate($L, $T.class)", mongoOpsRef, aggregationVariableName, outputType);
@ -152,13 +156,19 @@ class AggregationBlocks {
} }
private static Class<?> getOutputType(MongoQueryMethod queryMethod) { private static Class<?> getOutputType(SimpleTypeHolder simpleTypeHolder, MongoQueryMethod queryMethod) {
Class<?> outputType = queryMethod.getReturnedObjectType(); Class<?> outputType = queryMethod.getReturnedObjectType();
if (MongoSimpleTypes.HOLDER.isSimpleType(outputType)) {
outputType = Document.class; if (simpleTypeHolder.isSimpleType(outputType)) {
} else if (ClassUtils.isAssignable(AggregationResults.class, outputType) && queryMethod.getReturnType().getComponentType() != null) { return Document.class;
outputType = queryMethod.getReturnType().getComponentType().getType();
} }
if (ClassUtils.isAssignable(AggregationResults.class, outputType)
&& queryMethod.getReturnType().getComponentType() != null) {
return queryMethod.getReturnType().getComponentType().getType();
}
return outputType; return outputType;
} }
@ -166,6 +176,7 @@ class AggregationBlocks {
static class AggregationCodeBlockBuilder { static class AggregationCodeBlockBuilder {
private final AotQueryMethodGenerationContext context; private final AotQueryMethodGenerationContext context;
private final SimpleTypeHolder simpleTypeHolder;
private final MongoQueryMethod queryMethod; private final MongoQueryMethod queryMethod;
private final String parameterNames; private final String parameterNames;
@ -174,9 +185,11 @@ class AggregationBlocks {
private String aggregationVariableName; private String aggregationVariableName;
private boolean pipelineOnly; private boolean pipelineOnly;
AggregationCodeBlockBuilder(AotQueryMethodGenerationContext context, MongoQueryMethod queryMethod) { AggregationCodeBlockBuilder(AotQueryMethodGenerationContext context, SimpleTypeHolder simpleTypeHolder,
MongoQueryMethod queryMethod) {
this.context = context; this.context = context;
this.simpleTypeHolder = simpleTypeHolder;
this.queryMethod = queryMethod; this.queryMethod = queryMethod;
this.parameterNames = StringUtils.collectionToDelimitedString(context.getAllParameterNames(), ", "); this.parameterNames = StringUtils.collectionToDelimitedString(context.getAllParameterNames(), ", ");
} }
@ -230,7 +243,7 @@ class AggregationBlocks {
builder.add(aggregationStages(context.localVariable("stages"), source.stages())); builder.add(aggregationStages(context.localVariable("stages"), source.stages()));
if (StringUtils.hasText(sortParameter)) { if (StringUtils.hasText(sortParameter)) {
Class<?> outputType = getOutputType(queryMethod); Class<?> outputType = getOutputType(simpleTypeHolder, queryMethod);
builder.add(sortingStage(sortParameter, outputType)); builder.add(sortingStage(sortParameter, outputType));
} }
@ -324,7 +337,7 @@ class AggregationBlocks {
context.localVariable("sortDocument"), context.localVariable("order")); context.localVariable("sortDocument"), context.localVariable("order"));
builder.endControlFlow(); builder.endControlFlow();
if (outputType == Document.class || MongoSimpleTypes.HOLDER.isSimpleType(outputType) if (outputType == Document.class || simpleTypeHolder.isSimpleType(outputType)
|| ClassUtils.isAssignable(context.getRepositoryInformation().getDomainType(), outputType)) { || ClassUtils.isAssignable(context.getRepositoryInformation().getDomainType(), outputType)) {
builder.addStatement("$L.add(new $T($S, $L))", context.localVariable("stages"), Document.class, "$sort", builder.addStatement("$L.add(new $T($S, $L))", context.localVariable("stages"), Document.class, "$sort",
context.localVariable("sortDocument")); context.localVariable("sortDocument"));
@ -343,7 +356,7 @@ class AggregationBlocks {
Builder builder = CodeBlock.builder(); Builder builder = CodeBlock.builder();
builder.add(sortingStage(pageableProvider + ".getSort()", getOutputType(queryMethod))); builder.add(sortingStage(pageableProvider + ".getSort()", getOutputType(simpleTypeHolder, queryMethod)));
builder.beginControlFlow("if ($L.isPaged())", pageableProvider); builder.beginControlFlow("if ($L.isPaged())", pageableProvider);
builder.beginControlFlow("if ($L.getOffset() > 0)", pageableProvider); builder.beginControlFlow("if ($L.getOffset() > 0)", pageableProvider);

3
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotPlaceholders.java
Unescape View File

@ -279,7 +279,8 @@ class AotPlaceholders {
this.options = options; this.options = options;
} }
@Nullable String regexOptions() { @Nullable
String regexOptions() {
return options; return options;
} }

25
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotQueryCreator.java
Unescape View File

@ -68,13 +68,7 @@ import com.mongodb.DBRef;
* @author Christoph Strobl * @author Christoph Strobl
* @since 5.0 * @since 5.0
*/ */
class AotQueryCreator { record AotQueryCreator(MappingContext<?, MongoPersistentProperty> mappingContext) {
private final MappingContext<?, MongoPersistentProperty> mappingContext;
public AotQueryCreator(MappingContext<?, MongoPersistentProperty> mappingContext) {
this.mappingContext = mappingContext;
}
@SuppressWarnings("NullAway") @SuppressWarnings("NullAway")
AotStringQuery createQuery(PartTree partTree, QueryMethod queryMethod, Method source) { AotStringQuery createQuery(PartTree partTree, QueryMethod queryMethod, Method source) {
@ -179,7 +173,8 @@ class AotQueryCreator {
private final List<Object> placeholders; private final List<Object> placeholders;
@Nullable Part getPartForIndex(PartTree partTree, Parameter parameter) { @Nullable
Part getPartForIndex(PartTree partTree, Parameter parameter) {
if (!parameter.isBindable()) { if (!parameter.isBindable()) {
return null; return null;
} }
@ -197,16 +192,13 @@ class AotQueryCreator {
public PlaceholderParameterAccessor(PartTree partTree, QueryMethod queryMethod) { public PlaceholderParameterAccessor(PartTree partTree, QueryMethod queryMethod) {
if (queryMethod.getParameters().getNumberOfParameters() == 0) { if (queryMethod.getParameters().getNumberOfParameters() == 0) {
placeholders = List.of(); placeholders = List.of();
} else { } else {
placeholders = new ArrayList<>(); placeholders = new ArrayList<>();
Parameters<?, ?> parameters = queryMethod.getParameters(); Parameters<?, ?> parameters = queryMethod.getParameters();
for (Parameter parameter : parameters.toList()) { for (Parameter parameter : parameters.toList()) {
if (ClassUtils.isAssignable(GeoJson.class, parameter.getType())) { if (ClassUtils.isAssignable(GeoJson.class, parameter.getType())) {
placeholders.add(parameter.getIndex(), AotPlaceholders.geoJson(parameter.getIndex(), "")); placeholders.add(parameter.getIndex(), AotPlaceholders.geoJson(parameter.getIndex(), ""));
@ -224,8 +216,15 @@ class AotQueryCreator {
placeholders.add(parameter.getIndex(), AotPlaceholders.regex(parameter.getIndex(), null)); placeholders.add(parameter.getIndex(), AotPlaceholders.regex(parameter.getIndex(), null));
} else { } else {
Part partForIndex = getPartForIndex(partTree, parameter); Part partForIndex = getPartForIndex(partTree, parameter);
if(partForIndex != null && (partForIndex.getType().equals(Type.LIKE) || partForIndex.getType().equals(Type.NOT_LIKE))) { if (partForIndex != null
placeholders.add(parameter.getIndex(), AotPlaceholders.regex(parameter.getIndex(), partForIndex.shouldIgnoreCase().equals(IgnoreCaseType.ALWAYS) || partForIndex.shouldIgnoreCase().equals(IgnoreCaseType.WHEN_POSSIBLE) ? "i": null)); && (partForIndex.getType().equals(Type.LIKE) || partForIndex.getType().equals(Type.NOT_LIKE))) {
placeholders
.add(parameter.getIndex(),
AotPlaceholders
.regex(parameter.getIndex(),
partForIndex.shouldIgnoreCase().equals(IgnoreCaseType.ALWAYS)
|| partForIndex.shouldIgnoreCase().equals(IgnoreCaseType.WHEN_POSSIBLE) ? "i"
: null));
} else { } else {
placeholders.add(parameter.getIndex(), AotPlaceholders.indexed(parameter.getIndex())); placeholders.add(parameter.getIndex(), AotPlaceholders.indexed(parameter.getIndex()));
} }

4
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotStringQuery.java
Unescape View File

@ -28,7 +28,6 @@ import org.springframework.data.mongodb.core.query.Collation;
import org.springframework.data.mongodb.core.query.Field; import org.springframework.data.mongodb.core.query.Field;
import org.springframework.data.mongodb.core.query.Meta; import org.springframework.data.mongodb.core.query.Meta;
import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.repository.aot.AotPlaceholders.Placeholder;
import org.springframework.data.mongodb.repository.aot.AotPlaceholders.RegexPlaceholder; import org.springframework.data.mongodb.repository.aot.AotPlaceholders.RegexPlaceholder;
import org.springframework.util.StringUtils; import org.springframework.util.StringUtils;
@ -87,7 +86,8 @@ class AotStringQuery extends Query {
return this.placeholders.get(index) instanceof RegexPlaceholder; return this.placeholders.get(index) instanceof RegexPlaceholder;
} }
@Nullable String getRegexOptions(int index) { @Nullable
String getRegexOptions(int index) {
if (this.placeholders.isEmpty()) { if (this.placeholders.isEmpty()) {
return null; return null;
} }

1
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoAotRepositoryFragmentSupport.java
Unescape View File

@ -189,7 +189,6 @@ public class MongoAotRepositoryFragmentSupport {
criteria.lt(value); criteria.lt(value);
} }
} }
}; };
} }

9
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoCodeBlocks.java
Unescape View File

@ -20,6 +20,7 @@ import java.util.regex.Pattern;
import org.bson.Document; import org.bson.Document;
import org.jspecify.annotations.Nullable; import org.jspecify.annotations.Nullable;
import org.springframework.core.annotation.MergedAnnotation; import org.springframework.core.annotation.MergedAnnotation;
import org.springframework.data.mapping.model.SimpleTypeHolder;
import org.springframework.data.mongodb.repository.ReadPreference; import org.springframework.data.mongodb.repository.ReadPreference;
import org.springframework.data.mongodb.repository.aot.AggregationBlocks.AggregationCodeBlockBuilder; import org.springframework.data.mongodb.repository.aot.AggregationBlocks.AggregationCodeBlockBuilder;
import org.springframework.data.mongodb.repository.aot.AggregationBlocks.AggregationExecutionCodeBlockBuilder; import org.springframework.data.mongodb.repository.aot.AggregationBlocks.AggregationExecutionCodeBlockBuilder;
@ -118,24 +119,28 @@ class MongoCodeBlocks {
* Builder for generating aggregation (pipeline) parsing {@link CodeBlock}. * Builder for generating aggregation (pipeline) parsing {@link CodeBlock}.
* *
* @param context * @param context
* @param simpleTypeHolder
* @param queryMethod * @param queryMethod
* @return * @return
*/ */
static AggregationCodeBlockBuilder aggregationBlockBuilder(AotQueryMethodGenerationContext context, static AggregationCodeBlockBuilder aggregationBlockBuilder(AotQueryMethodGenerationContext context,
SimpleTypeHolder simpleTypeHolder,
MongoQueryMethod queryMethod) { MongoQueryMethod queryMethod) {
return new AggregationCodeBlockBuilder(context, queryMethod); return new AggregationCodeBlockBuilder(context, simpleTypeHolder, queryMethod);
} }
/** /**
* Builder for generating aggregation execution {@link CodeBlock}. * Builder for generating aggregation execution {@link CodeBlock}.
* *
* @param context * @param context
* @param simpleTypeHolder
* @param queryMethod * @param queryMethod
* @return * @return
*/ */
static AggregationExecutionCodeBlockBuilder aggregationExecutionBlockBuilder(AotQueryMethodGenerationContext context, static AggregationExecutionCodeBlockBuilder aggregationExecutionBlockBuilder(AotQueryMethodGenerationContext context,
SimpleTypeHolder simpleTypeHolder,
MongoQueryMethod queryMethod) { MongoQueryMethod queryMethod) {
return new AggregationExecutionCodeBlockBuilder(context, queryMethod); return new AggregationExecutionCodeBlockBuilder(context, simpleTypeHolder, queryMethod);
} }
/** /**

31
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoRepositoryContributor.java
Unescape View File

@ -28,6 +28,7 @@ import org.jspecify.annotations.Nullable;
import org.springframework.core.annotation.AnnotatedElementUtils; import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.data.mapping.model.SimpleTypeHolder;
import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.AggregationUpdate; import org.springframework.data.mongodb.core.aggregation.AggregationUpdate;
import org.springframework.data.mongodb.core.convert.MongoCustomConversions; import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
@ -68,6 +69,7 @@ public class MongoRepositoryContributor extends RepositoryContributor {
private static final Log logger = LogFactory.getLog(MongoRepositoryContributor.class); private static final Log logger = LogFactory.getLog(MongoRepositoryContributor.class);
private final AotQueryCreator queryCreator; private final AotQueryCreator queryCreator;
private final SimpleTypeHolder simpleTypeHolder;
private final MongoMappingContext mappingContext; private final MongoMappingContext mappingContext;
private final NamedQueries namedQueries; private final NamedQueries namedQueries;
@ -85,8 +87,10 @@ public class MongoRepositoryContributor extends RepositoryContributor {
MongoCustomConversions mongoCustomConversions = MongoCustomConversions MongoCustomConversions mongoCustomConversions = MongoCustomConversions
.create(MongoCustomConversions.MongoConverterConfigurationAdapter::useNativeDriverJavaTimeCodecs); .create(MongoCustomConversions.MongoConverterConfigurationAdapter::useNativeDriverJavaTimeCodecs);
this.simpleTypeHolder = mongoCustomConversions.getSimpleTypeHolder();
this.mappingContext = new MongoMappingContext(); this.mappingContext = new MongoMappingContext();
this.mappingContext.setSimpleTypeHolder(mongoCustomConversions.getSimpleTypeHolder()); this.mappingContext.setSimpleTypeHolder(this.simpleTypeHolder);
this.mappingContext.setAutoIndexCreation(false); this.mappingContext.setAutoIndexCreation(false);
this.mappingContext.afterPropertiesSet(); this.mappingContext.afterPropertiesSet();
@ -150,7 +154,7 @@ public class MongoRepositoryContributor extends RepositoryContributor {
if (queryMethod.hasAnnotatedAggregation()) { if (queryMethod.hasAnnotatedAggregation()) {
AggregationInteraction aggregation = new AggregationInteraction(queryMethod.getAnnotatedAggregation()); AggregationInteraction aggregation = new AggregationInteraction(queryMethod.getAnnotatedAggregation());
queryMetadata = aggregation; queryMetadata = aggregation;
contribution = aggregationMethodContributor(queryMethod, aggregation); contribution = aggregationMethodContributor(queryMethod, simpleTypeHolder, aggregation);
} else { } else {
QueryInteraction query = createStringQuery(getRepositoryInformation(), queryMethod, QueryInteraction query = createStringQuery(getRepositoryInformation(), queryMethod,
@ -193,7 +197,7 @@ public class MongoRepositoryContributor extends RepositoryContributor {
if (!ObjectUtils.isEmpty(updateSource.pipeline())) { if (!ObjectUtils.isEmpty(updateSource.pipeline())) {
AggregationUpdateInteraction update = new AggregationUpdateInteraction(query, updateSource.pipeline()); AggregationUpdateInteraction update = new AggregationUpdateInteraction(query, updateSource.pipeline());
queryMetadata = update; queryMetadata = update;
contribution = aggregationUpdateMethodContributor(queryMethod, update); contribution = aggregationUpdateMethodContributor(queryMethod, simpleTypeHolder, update);
} }
} }
} else { } else {
@ -210,17 +214,7 @@ public class MongoRepositoryContributor extends RepositoryContributor {
return MethodContributor.forQueryMethod(queryMethod).metadataOnly(queryMetadata); return MethodContributor.forQueryMethod(queryMethod).metadataOnly(queryMetadata);
} }
MethodContributor.RepositoryMethodContribution finalContribution = contribution; return MethodContributor.forQueryMethod(queryMethod).withMetadata(queryMetadata).contribute(contribution);
return MethodContributor.forQueryMethod(queryMethod).withMetadata(queryMetadata).contribute(context -> {
CodeBlock.Builder builder = CodeBlock.builder();
// builder.addStatement("class ExpressionMarker{}");
builder.add(finalContribution.contribute(context));
return builder.build();
});
} }
@SuppressWarnings("NullAway") @SuppressWarnings("NullAway")
@ -289,6 +283,7 @@ public class MongoRepositoryContributor extends RepositoryContributor {
} }
static MethodContributor.RepositoryMethodContribution aggregationMethodContributor(MongoQueryMethod queryMethod, static MethodContributor.RepositoryMethodContribution aggregationMethodContributor(MongoQueryMethod queryMethod,
SimpleTypeHolder simpleTypeHolder,
AggregationInteraction aggregation) { AggregationInteraction aggregation) {
return context -> { return context -> {
@ -297,9 +292,10 @@ public class MongoRepositoryContributor extends RepositoryContributor {
String variableName = context.localVariable("aggregation"); String variableName = context.localVariable("aggregation");
builder.add(aggregationBlockBuilder(context, queryMethod).stages(aggregation) builder.add(aggregationBlockBuilder(context, simpleTypeHolder, queryMethod).stages(aggregation)
.usingAggregationVariableName(variableName).build()); .usingAggregationVariableName(variableName).build());
builder.add(aggregationExecutionBlockBuilder(context, queryMethod).referencing(variableName).build()); builder.add(
aggregationExecutionBlockBuilder(context, simpleTypeHolder, queryMethod).referencing(variableName).build());
return builder.build(); return builder.build();
}; };
@ -351,6 +347,7 @@ public class MongoRepositoryContributor extends RepositoryContributor {
} }
static MethodContributor.RepositoryMethodContribution aggregationUpdateMethodContributor(MongoQueryMethod queryMethod, static MethodContributor.RepositoryMethodContribution aggregationUpdateMethodContributor(MongoQueryMethod queryMethod,
SimpleTypeHolder simpleTypeHolder,
AggregationUpdateInteraction update) { AggregationUpdateInteraction update) {
return context -> { return context -> {
@ -364,7 +361,7 @@ public class MongoRepositoryContributor extends RepositoryContributor {
// update definition // update definition
String updateVariableName = context.localVariable("updateDefinition"); String updateVariableName = context.localVariable("updateDefinition");
builder.add(aggregationBlockBuilder(context, queryMethod).stages(update) builder.add(aggregationBlockBuilder(context, simpleTypeHolder, queryMethod).stages(update)
.usingAggregationVariableName(updateVariableName).pipelineOnly(true).build()); .usingAggregationVariableName(updateVariableName).pipelineOnly(true).build());
builder.addStatement("$T $L = $T.from($L.getOperations())", AggregationUpdate.class, builder.addStatement("$T $L = $T.from($L.getOperations())", AggregationUpdate.class,

1
spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/Snippet.java
Unescape View File

@ -195,7 +195,6 @@ interface Snippet {
public BuilderStyleBuilder with(Snippet snippet) { public BuilderStyleBuilder with(Snippet snippet) {
Assert.notNull(targetMethodName, "TargetMethodName must be set before calling this method"); Assert.notNull(targetMethodName, "TargetMethodName must be set before calling this method");
new BuilderStyleSnippet(targetVariableName, targetMethodName, snippet).appendTo(targetBuilder); new BuilderStyleSnippet(targetVariableName, targetMethodName, snippet).appendTo(targetBuilder);
return this; return this;
} }

40
spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java
Unescape View File

@ -15,31 +15,10 @@
*/ */
package org.springframework.data.mongodb.core.aggregation; package org.springframework.data.mongodb.core.aggregation;
import static org.springframework.data.domain.Sort.Direction.ASC; import static org.springframework.data.domain.Sort.Direction.*;
import static org.springframework.data.domain.Sort.Direction.DESC; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.DEFAULT_CONTEXT; import static org.springframework.data.mongodb.core.query.Criteria.*;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.bind; import static org.springframework.data.mongodb.test.util.Assertions.*;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.bucket;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.bucketAuto;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.count;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.facet;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.group;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.limit;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.lookup;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.match;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.newAggregation;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.newAggregationOptions;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.out;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.previousOperation;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.project;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.replaceRoot;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.sample;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.skip;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.sort;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.unwind;
import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.test.util.Assertions.assertThat;
import static org.springframework.data.mongodb.test.util.Assertions.assertThatIllegalArgumentException;
import java.io.BufferedInputStream; import java.io.BufferedInputStream;
import java.text.ParseException; import java.text.ParseException;
@ -67,6 +46,7 @@ import org.bson.Document;
import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.AfterEach;
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.core.io.ClassPathResource; import org.springframework.core.io.ClassPathResource;
import org.springframework.data.annotation.Id; import org.springframework.data.annotation.Id;
import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort;
@ -3116,8 +3096,8 @@ public class AggregationTests {
} }
} }
@Test @Test // GH-5027
void xxx() { void shouldAggregateAsInterface() {
MyOhMy source = new MyOhMy(); MyOhMy source = new MyOhMy();
source.id = "id-1"; source.id = "id-1";
@ -3127,8 +3107,8 @@ public class AggregationTests {
mongoTemplate.save(source); mongoTemplate.save(source);
TypedAggregation<MyOhMy> agg = newAggregation(MyOhMy.class, project("firstname")); TypedAggregation<MyOhMy> agg = newAggregation(MyOhMy.class, project("firstname"));
AggregationResults<MyMyOh> aggregate = mongoTemplate.aggregate(agg, MyMyOh.class); AggregationResults<MyMyOhInterface> aggregate = mongoTemplate.aggregate(agg, MyMyOhInterface.class);
assertThat(aggregate.getMappedResults()).hasOnlyElementsOfType(MyMyOh.class); assertThat(aggregate.getMappedResults()).hasOnlyElementsOfType(MyMyOhInterface.class);
} }
static class MyOhMy { static class MyOhMy {
@ -3137,7 +3117,7 @@ public class AggregationTests {
String lastname; String lastname;
} }
interface MyMyOh { interface MyMyOhInterface {
String getFirstname(); String getFirstname();
} }
} }

Write Preview
Loading…
Cancel
Save