Polishing.

Refactor evaluation handling, align with JPA using MongoParameters and the originating Method. Add support for reactive GeoNear count.

Author: mp911de

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveFindOperation.java

@@ -194,6 +194,14 @@ interface TerminatingFindNear<T> {
 		 * @return never {@literal null}.
 		 */
 		Flux<GeoResult<T>> all();
+
+		/**
+		 * Count matching elements.
+		 *
+		 * @return number of elements matching the query.
+		 * @since 5.0
+		 */
+		Mono<Long> count();
 	}
 
 	/**

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveFindOperationSupport.java

@@ -239,6 +239,11 @@ public <R> TerminatingFindNear<R> map(QueryResultConverter<? super G, ? extends
 			public Flux<GeoResult<G>> all() {
 				return template.doGeoNear(nearQuery, domainType, getCollectionName(), returnType, resultConverter);
 			}
+
+			@Override
+			public Mono<Long> count() {
+				return template.doGeoNearCount(nearQuery, domainType, getCollectionName());
+			}
 		}
 
 		/**

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMongoTemplate.java

@@ -47,6 +47,7 @@
 import org.jspecify.annotations.Nullable;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
+
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
@@ -1015,30 +1016,38 @@ public <O> Flux<O> aggregate(Aggregation aggregation, String collectionName, Cla
 
 	protected <O> Flux<O> doAggregate(Aggregation aggregation, String collectionName, @Nullable Class<?> inputType,
 			Class<O> outputType) {
-		return doAggregate(aggregation, collectionName, inputType, outputType, QueryResultConverter.entity());
+
+		AggregationDefinition context = queryOperations.createAggregation(aggregation, inputType);
+		return doAggregate(aggregation, collectionName, outputType, QueryResultConverter.entity(), context);
 	}
 
 	<T, O> Flux<O> doAggregate(Aggregation aggregation, String collectionName, @Nullable Class<?> inputType,
 			Class<T> outputType, QueryResultConverter<? super T, ? extends O> resultConverter) {
 
+		AggregationDefinition context = queryOperations.createAggregation(aggregation, inputType);
+		return doAggregate(aggregation, collectionName, outputType, resultConverter, context);
+	}
+
+	<T, O> Flux<O> doAggregate(Aggregation aggregation, String collectionName, Class<T> outputType,
+			QueryResultConverter<? super T, ? extends O> resultConverter, AggregationDefinition definition) {
+
 		Assert.notNull(aggregation, "Aggregation pipeline must not be null");
 		Assert.hasText(collectionName, "Collection name must not be null or empty");
 		Assert.notNull(outputType, "Output type must not be null");
 
 		AggregationOptions options = aggregation.getOptions();
 		Assert.isTrue(!options.isExplain(), "Cannot use explain option with streaming");
 
-		AggregationDefinition ctx = queryOperations.createAggregation(aggregation, inputType);
 
 		if (LOGGER.isDebugEnabled()) {
 			LOGGER.debug(String.format("Streaming aggregation: %s in collection %s",
-					serializeToJsonSafely(ctx.getAggregationPipeline()), collectionName));
+					serializeToJsonSafely(definition.getAggregationPipeline()), collectionName));
 		}
 
 		DocumentCallback<O> readCallback = new QueryResultConverterCallback<>(resultConverter,
 				new ReadDocumentCallback<>(mongoConverter, outputType, collectionName));
-		return execute(collectionName, collection -> aggregateAndMap(collection, ctx.getAggregationPipeline(),
-				ctx.isOutOrMerge(), options, readCallback, ctx.getInputType()));
+		return execute(collectionName, collection -> aggregateAndMap(collection, definition.getAggregationPipeline(),
+				definition.isOutOrMerge(), options, readCallback, definition.getInputType()));
 	}
 
 	private <O> Flux<O> aggregateAndMap(MongoCollection<Document> collection, List<Document> pipeline,
@@ -1093,6 +1102,33 @@ protected <T> Flux<GeoResult<T>> geoNear(NearQuery near, Class<?> entityClass, S
 		return doGeoNear(near, entityClass, collectionName, returnType, QueryResultConverter.entity());
 	}
 
+	Mono<Long> doGeoNearCount(NearQuery near, Class<?> domainType, String collectionName) {
+
+		Builder optionsBuilder = AggregationOptions.builder().collation(near.getCollation());
+
+		if (near.hasReadPreference()) {
+			optionsBuilder.readPreference(near.getReadPreference());
+		}
+
+		if (near.hasReadConcern()) {
+			optionsBuilder.readConcern(near.getReadConcern());
+		}
+
+		String distanceField = operations.nearQueryDistanceFieldName(domainType);
+		Aggregation $geoNear = TypedAggregation.newAggregation(domainType,
+				Aggregation.geoNear(near, distanceField).skip(-1).limit(-1), Aggregation.count().as("_totalCount"))
+				.withOptions(optionsBuilder.build());
+
+		AggregationDefinition definition = queryOperations.createAggregation($geoNear, (AggregationOperationContext) null);
+
+		Flux<Document> results = doAggregate($geoNear, collectionName, Document.class, QueryResultConverter.entity(),
+				definition);
+
+		return results.last()
+				.map(doc -> NumberUtils.convertNumberToTargetClass(doc.get("_totalCount", Integer.class), Long.class))
+				.defaultIfEmpty(0L);
+	}
+
 	@SuppressWarnings("unchecked")
 	<T, R> Flux<GeoResult<R>> doGeoNear(NearQuery near, Class<?> entityClass, String collectionName, Class<T> returnType,
 			QueryResultConverter<? super T, ? extends R> resultConverter) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/CriteriaDefinition.java

@@ -50,7 +50,7 @@ interface Placeholder {
 
 		/**
 		 * Create a new placeholder for index bindable parameter.
-		 * 
+		 *
 		 * @param position the index of the parameter to bind.
 		 * @return new instance of {@link Placeholder}.
 		 */
@@ -65,20 +65,4 @@ static Placeholder placeholder(String expression) {
 		Object getValue();
 	}
 
-	static class PlaceholderImpl implements Placeholder {
-		private final Object expression;
-
-		public PlaceholderImpl(Object expression) {
-			this.expression = expression;
-		}
-
-		@Override
-		public Object getValue() {
-			return expression;
-		}
-
-		public String toString() {
-			return getValue().toString();
-		}
-	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/GeoCommand.java

@@ -76,10 +76,9 @@ private String getCommand(Shape shape) {
 
 		Assert.notNull(shape, "Shape must not be null");
 
-		if(shape instanceof GeoJson<?>) {
+		if (shape instanceof GeoJson<?>) {
 			return "$geometry";
-		}
-		if (shape instanceof Box) {
+		} else if (shape instanceof Box) {
 			return "$box";
 		} else if (shape instanceof Circle) {
 			return "$center";

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/PlaceholderImpl.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.query;
+
+/**
+ * @author Christoph Strobl
+ * @since 5.0
+ */
+record PlaceholderImpl(Object expression) implements CriteriaDefinition.Placeholder {
+
+	@Override
+	public Object getValue() {
+		return expression;
+	}
+
+	public String toString() {
+		return getValue().toString();
+	}
+
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AggregationBlocks.java

@@ -16,13 +16,13 @@
 package org.springframework.data.mongodb.repository.aot;
 
 import java.util.ArrayList;
-import java.util.LinkedHashMap;
+import java.util.Collection;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Stream;
 
 import org.bson.Document;
 import org.jspecify.annotations.NullUnmarked;
+
 import org.springframework.core.ResolvableType;
 import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.data.domain.SliceImpl;
@@ -47,6 +47,8 @@
 import org.springframework.util.StringUtils;
 
 /**
+ * Code blocks for building aggregation pipelines and execution statements for MongoDB repositories.
+ *
  * @author Christoph Strobl
  * @since 5.0
  */
@@ -160,7 +162,7 @@ static class AggregationCodeBlockBuilder {
 
 		private final AotQueryMethodGenerationContext context;
 		private final MongoQueryMethod queryMethod;
-		private final Map<String, CodeBlock> arguments;
+		private final String parameterNames;
 
 		private AggregationInteraction source;
 
@@ -170,9 +172,8 @@ static class AggregationCodeBlockBuilder {
 		AggregationCodeBlockBuilder(AotQueryMethodGenerationContext context, MongoQueryMethod queryMethod) {
 
 			this.context = context;
-			this.arguments = new LinkedHashMap<>();
-			context.getBindableParameterNames().forEach(it -> arguments.put(it, CodeBlock.of(it)));
 			this.queryMethod = queryMethod;
+			this.parameterNames = StringUtils.collectionToDelimitedString(context.getAllParameterNames(), ", ");
 		}
 
 		AggregationCodeBlockBuilder stages(AggregationInteraction aggregation) {
@@ -220,33 +221,18 @@ private CodeBlock pipeline(String pipelineVariableName) {
 			String limitParameter = context.getLimitParameterName();
 			String pageableParameter = context.getPageableParameterName();
 
-			boolean mightBeSorted = StringUtils.hasText(sortParameter);
-			boolean mightBeLimited = StringUtils.hasText(limitParameter);
-			boolean mightBePaged = StringUtils.hasText(pageableParameter);
-
-			int stageCount = source.stages().size();
-			if (mightBeSorted) {
-				stageCount++;
-			}
-			if (mightBeLimited) {
-				stageCount++;
-			}
-			if (mightBePaged) {
-				stageCount += 3;
-			}
-
 			Builder builder = CodeBlock.builder();
-			builder.add(aggregationStages(context.localVariable("stages"), source.stages(), stageCount, arguments));
+			builder.add(aggregationStages(context.localVariable("stages"), source.stages()));
 
-			if (mightBeSorted) {
+			if (StringUtils.hasText(sortParameter)) {
 				builder.add(sortingStage(sortParameter));
 			}
 
-			if (mightBeLimited) {
+			if (StringUtils.hasText(limitParameter)) {
 				builder.add(limitingStage(limitParameter));
 			}
 
-			if (mightBePaged) {
+			if (StringUtils.hasText(pageableParameter)) {
 				builder.add(pagingStage(pageableParameter, queryMethod.isSliceQuery()));
 			}
 
@@ -259,6 +245,7 @@ private CodeBlock aggregationOptions(String aggregationVariableName) {
 
 			Builder builder = CodeBlock.builder();
 			List<CodeBlock> options = new ArrayList<>(5);
+
 			if (ReflectionUtils.isVoid(queryMethod.getReturnedObjectType())) {
 				options.add(CodeBlock.of(".skipOutput()"));
 			}
@@ -299,20 +286,21 @@ private CodeBlock aggregationOptions(String aggregationVariableName) {
 			return builder.build();
 		}
 
-		private CodeBlock aggregationStages(String stageListVariableName, Iterable<String> stages, int stageCount,
-				Map<String, CodeBlock> arguments) {
+		private CodeBlock aggregationStages(String stageListVariableName, Collection<String> stages) {
 
 			Builder builder = CodeBlock.builder();
 			builder.addStatement("$T<$T> $L = new $T($L)", List.class, Object.class, stageListVariableName, ArrayList.class,
-					stageCount);
+					stages.size());
 			int stageCounter = 0;
 
 			for (String stage : stages) {
 
 				VariableSnippet stageSnippet = Snippet.declare(builder)
-						.variable(Document.class, context.localVariable("stage_%s".formatted(stageCounter++)))
-						.of(MongoCodeBlocks.asDocument(stage, arguments));
+						.variable(Document.class, context.localVariable("stage_%s".formatted(stageCounter)))
+						.of(MongoCodeBlocks.asDocument(stage, parameterNames));
 				builder.addStatement("$L.add($L)", stageListVariableName, stageSnippet.getVariableName());
+
+				stageCounter++;
 			}
 
 			return builder.build();

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/GeoBlocks.java

@@ -15,6 +15,8 @@
  */
 package org.springframework.data.mongodb.repository.aot;
 
+import org.jspecify.annotations.NullUnmarked;
+
 import org.springframework.data.geo.Distance;
 import org.springframework.data.geo.GeoPage;
 import org.springframework.data.geo.GeoResults;
@@ -27,11 +29,14 @@
 import org.springframework.util.ClassUtils;
 
 /**
+ * Code blocks for generating code related to geo-near queries in MongoDB repositories.
+ *
  * @author Christoph Strobl
  * @since 5.0
  */
 class GeoBlocks {
 
+	@NullUnmarked
 	static class GeoNearCodeBlockBuilder {
 
 		private final AotQueryMethodGenerationContext context;
@@ -91,16 +96,15 @@ public GeoNearCodeBlockBuilder usingQueryVariableName(String variableName) {
 		}
 	}
 
+	@NullUnmarked
 	static class GeoNearExecutionCodeBlockBuilder {
 
 		private final AotQueryMethodGenerationContext context;
-		private final MongoQueryMethod queryMethod;
 		private String queryVariableName;
 
-		GeoNearExecutionCodeBlockBuilder(AotQueryMethodGenerationContext context, MongoQueryMethod queryMethod) {
+		GeoNearExecutionCodeBlockBuilder(AotQueryMethodGenerationContext context) {
 
 			this.context = context;
-			this.queryMethod = queryMethod;
 		}
 
 		GeoNearExecutionCodeBlockBuilder referencing(String queryVariableName) {