GeoNear query with additional filter

christophstrobl · christophstrobl · commit fbceb946a47e · 2025-06-18T11:44:41.000+02:00
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotQueryCreator.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/AotQueryCreator.java
@@ -49,6 +49,7 @@
 import org.springframework.data.mongodb.repository.query.ConvertingParameterAccessor;
 import org.springframework.data.mongodb.repository.query.MongoParameterAccessor;
 import org.springframework.data.mongodb.repository.query.MongoQueryCreator;
+import org.springframework.data.mongodb.repository.query.MongoQueryMethod;
 import org.springframework.data.repository.query.Parameter;
 import org.springframework.data.repository.query.Parameters;
 import org.springframework.data.repository.query.QueryMethod;
@@ -80,8 +81,11 @@ public AotQueryCreator() {
 	@SuppressWarnings("NullAway")
 	StringQuery createQuery(PartTree partTree, QueryMethod queryMethod) {
 
+
+		boolean geoNear = queryMethod instanceof MongoQueryMethod mqm ? mqm.isGeoNearQuery() : false;
+
 		Query query = new MongoQueryCreator(partTree,
-				new PlaceholderConvertingParameterAccessor(new PlaceholderParameterAccessor(queryMethod)), mappingContext)
+				new PlaceholderConvertingParameterAccessor(new PlaceholderParameterAccessor(queryMethod)), mappingContext, geoNear, queryMethod.isSearchQuery())
 				.createQuery();
 
 		if (partTree.isLimiting()) {
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoRepositoryContributor.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/MongoRepositoryContributor.java
@@ -110,15 +110,15 @@ protected void customizeConstructor(AotRepositoryConstructorBuilder constructorB
 			return aggregationMethodContributor(queryMethod, aggregation);
 		}
 
+		QueryInteraction query = createStringQuery(getRepositoryInformation(), queryMethod,
+				AnnotatedElementUtils.findMergedAnnotation(method, Query.class), method.getParameterCount());
+
 		if (queryMethod.isGeoNearQuery() || (queryMethod.getParameters().getMaxDistanceIndex() != -1
 				&& queryMethod.getReturnType().isCollectionLike())) {
-			NearQueryInteraction near = new NearQueryInteraction();
+			NearQueryInteraction near = new NearQueryInteraction(query);
 			return nearQueryMethodContributor(queryMethod, near);
 		}
 
-		QueryInteraction query = createStringQuery(getRepositoryInformation(), queryMethod,
-				AnnotatedElementUtils.findMergedAnnotation(method, Query.class), method.getParameterCount());
-
 		if (queryMethod.hasAnnotatedQuery()) {
 			if (StringUtils.hasText(queryMethod.getAnnotatedQuery())
 					&& Pattern.compile("[\\?:][#$]\\{.*\\}").matcher(queryMethod.getAnnotatedQuery()).find()) {
@@ -206,8 +206,16 @@ private static MethodContributor<MongoQueryMethod> nearQueryMethodContributor(Mo
 
 			CodeBlock.Builder builder = CodeBlock.builder();
 
-			String variableName = "nearQuery";
+			String variableName = context.localVariable("nearQuery");
 			builder.add(geoNearBlockBuilder(context, queryMethod).usingQueryVariableName(variableName).build());
+
+			if (!context.getBindableParameterNames().isEmpty()) {
+				String filterQueryVariableName = context.localVariable("filterQuery");
+				builder.add(queryBlockBuilder(context, queryMethod).usingQueryVariableName(filterQueryVariableName)
+						.filter(interaction.getQuery()).build());
+				builder.addStatement("$L.query($L)", variableName, filterQueryVariableName);
+			}
+
 			builder.add(geoNearExecutionBlockBuilder(context, queryMethod).referencing(variableName).build());
 
 			return builder.build();
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/NearQueryInteraction.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/aot/NearQueryInteraction.java
@@ -18,6 +18,7 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 
+import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.repository.aot.generate.QueryMetadata;
 import org.springframework.util.StringUtils;
 
@@ -30,16 +31,22 @@
 class NearQueryInteraction extends MongoInteraction implements QueryMetadata {
 
 	private final InteractionType interactionType;
+	private final QueryInteraction query;
 
-	NearQueryInteraction() {
+	NearQueryInteraction(QueryInteraction query) {
 		interactionType = InteractionType.QUERY;
+		this.query = query;
 	}
 
 	@Override
 	InteractionType getExecutionType() {
 		return interactionType;
 	}
 
+	public QueryInteraction getQuery() {
+		return query;
+	}
+
 	@Override
 	public Map<String, Object> serialize() {
 
diff --git a/spring-data-mongodb/src/test/java/example/aot/UserRepository.java b/spring-data-mongodb/src/test/java/example/aot/UserRepository.java
@@ -129,6 +129,8 @@ public interface UserRepository extends CrudRepository<User, String> {
 
 	GeoResults<User> findByLocationCoordinatesNear(Point point, Distance maxDistance);
 
+	GeoResults<User> findByLocationCoordinatesNearAndLastname(Point point, Distance maxDistance, String lastname);
+
 	List<GeoResult<User>> findUserAsListByLocationCoordinatesNear(Point point, Distance maxDistance);
 
 	GeoResults<User> findByLocationCoordinatesNear(Point point, Range<Distance> distance);
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java
@@ -15,10 +15,12 @@
  */
 package org.springframework.data.mongodb.repository;
 
-import static java.util.Arrays.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.assertj.core.api.Assumptions.*;
-import static org.springframework.data.geo.Metrics.*;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.springframework.data.geo.Metrics.KILOMETERS;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -38,13 +40,22 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.extension.ExtendWith;
-
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.dao.IncorrectResultSizeDataAccessException;
-import org.springframework.data.domain.*;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.ExampleMatcher;
 import org.springframework.data.domain.ExampleMatcher.GenericPropertyMatcher;
+import org.springframework.data.domain.Limit;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Range;
+import org.springframework.data.domain.ScrollPosition;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Sort.Direction;
+import org.springframework.data.domain.Window;
 import org.springframework.data.geo.Box;
 import org.springframework.data.geo.Circle;
 import org.springframework.data.geo.Distance;
@@ -216,8 +227,8 @@ void appliesScrollPositionCorrectly() {
 	@Test // GH-4397
 	void appliesLimitToScrollingCorrectly() {
 
-		Window<Person> page = repository.findByLastnameLikeOrderByLastnameAscFirstnameAsc("*a*",
-				ScrollPosition.keyset(), Limit.of(2));
+		Window<Person> page = repository.findByLastnameLikeOrderByLastnameAscFirstnameAsc("*a*", ScrollPosition.keyset(),
+				Limit.of(2));
 
 		assertThat(page.isLast()).isFalse();
 		assertThat(page.size()).isEqualTo(2);
@@ -250,7 +261,8 @@ void executesPagedFinderCorrectly() {
 	@Test // GH-4397
 	void executesFinderCorrectlyWithSortAndLimit() {
 
-		List<Person> page = repository.findByLastnameLike("*a*", Sort.by(Direction.ASC, "lastname", "firstname"), Limit.of(2));
+		List<Person> page = repository.findByLastnameLike("*a*", Sort.by(Direction.ASC, "lastname", "firstname"),
+				Limit.of(2));
 
 		assertThat(page).containsExactly(carter, stefan);
 	}
@@ -462,6 +474,22 @@ void executesGeoNearQueryForResultsCorrectly() {
 		assertThat(results.getContent()).isNotEmpty();
 	}
 
+	@Test
+	void executesGeoNearQueryWithAdditionalFilterCorrectly() {
+
+		Point point = new Point(-73.99171, 40.738868);
+		dave.setLocation(point);
+		repository.save(dave);
+
+		Person p2 = new Person("fn", "ln", 42, Sex.MALE);
+		p2.setLocation(point);
+		repository.save(p2);
+
+		GeoResults<Person> results = repository.findByLocationNearAndLastname(new Point(-73.99, 40.73),
+				Distance.of(2000, Metrics.KILOMETERS), "ln");
+		assertThat(results.getContent()).hasSize(1);
+	}
+
 	@Test
 	void executesGeoPageQueryForResultsCorrectly() {
 
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepository.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepository.java
@@ -221,6 +221,7 @@ Window<Person> findByLastnameLikeOrderByLastnameAscFirstnameAsc(String lastname,
 	List<Person> findByNamedQuery(String firstname);
 
 	GeoResults<Person> findByLocationNear(Point point, Distance maxDistance);
+	GeoResults<Person> findByLocationNearAndLastname(Point point, Distance maxDistance, String Lastname);
 
 	// DATAMONGO-1110
 	GeoResults<Person> findPersonByLocationNear(Point point, Range<Distance> distance);
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/aot/AotFragmentTestConfigurationSupport.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/aot/AotFragmentTestConfigurationSupport.java
@@ -93,7 +93,7 @@ private Object getFragmentFacadeProxy(Object fragment) {
 					Method target = ReflectionUtils.findMethod(fragment.getClass(), method.getName(), method.getParameterTypes());
 
 					if (target == null) {
-						throw new NoSuchMethodException("Method [%s] is not implemented by [%s]".formatted(method, target));
+						throw new MethodNotImplementedException("Method [%s] is not implemented by [%s]".formatted(method, target));
 					}
 
 					try {
@@ -127,4 +127,11 @@ public ProjectionFactory getProjectionFactory() {
 			}
 		};
 	}
+
+	public static class MethodNotImplementedException extends RuntimeException {
+
+		public MethodNotImplementedException(String message) {
+			super(message);
+		}
+	}
 }
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/aot/MongoRepositoryContributorTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/aot/MongoRepositoryContributorTests.java
@@ -59,6 +59,7 @@
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
 import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
 import org.springframework.data.mongodb.core.geo.GeoJsonPolygon;
+import org.springframework.data.mongodb.repository.aot.AotFragmentTestConfigurationSupport.MethodNotImplementedException;
 import org.springframework.data.mongodb.test.util.Client;
 import org.springframework.data.mongodb.test.util.MongoClientExtension;
 import org.springframework.data.mongodb.test.util.MongoTestUtils;
@@ -675,6 +676,14 @@ void testNearWithGeoResult() {
 		assertThat(users).extracting(GeoResult::getContent).extracting(User::getUsername).containsExactly("leia");
 	}
 
+	@Test
+	void testNearWithAdditionalFilterQueryAsGeoResult() {
+
+		GeoResults<User> users = fragment.findByLocationCoordinatesNearAndLastname(new Point(-73.99, 40.73),
+				Distance.of(50, Metrics.KILOMETERS), "Organa");
+		assertThat(users).extracting(GeoResult::getContent).extracting(User::getUsername).containsExactly("leia");
+	}
+
 	@Test
 	void testNearReturningListOfGeoResult() {
 
@@ -695,7 +704,7 @@ void testNearWithRange() {
 	@Test
 	void testNearReturningGeoPage() {
 
-		assertThatExceptionOfType(NoSuchMethodException.class)
+		assertThatExceptionOfType(MethodNotImplementedException.class)
 				.isThrownBy(() -> fragment.findByLocationCoordinatesNear(new Point(-73.99, 40.73),
 						Distance.of(2000, Metrics.KILOMETERS), PageRequest.of(0, 1)));
 
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/aot/QueryMethodContributionUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/aot/QueryMethodContributionUnitTests.java
@@ -118,6 +118,21 @@ void rendersNearQueryForGeoResults() throws NoSuchMethodException {
 				.contains("NearQuery.near(point)") //
 				.contains("nearQuery.maxDistance(maxDistance).in(maxDistance.getMetric())") //
 				.contains(".withReadPreference(com.mongodb.ReadPreference.valueOf(\"NEAREST\")") //
+				.doesNotContain(".query(") //
+				.contains(".near(nearQuery).all()");
+	}
+
+	@Test
+	void rendersNearQueryWithFilterForGeoResults() throws NoSuchMethodException {
+
+		MethodSpec methodSpec = codeOf(UserRepository.class, "findByLocationCoordinatesNearAndLastname", Point.class,
+				Distance.class, String.class);
+
+		assertThat(methodSpec.toString()) //
+				.contains("NearQuery.near(point)") //
+				.contains("nearQuery.maxDistance(maxDistance).in(maxDistance.getMetric())") //
+				.contains("filterQuery = createQuery(\"{'lastname':?0}\", new java.lang.Object[]{ lastname })") //
+				.contains("nearQuery.query(filterQuery)") //
 				.contains(".near(nearQuery).all()");
 	}
 
@@ -151,6 +166,5 @@ interface UserRepoWithMeta extends Repository<User, String> {
 
 		@ReadPreference("NEAREST")
 		GeoResults<User> findByLocationCoordinatesNear(Point point, Distance maxDistance);
-
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ private Object getFragmentFacadeProxy(Object fragment) {`
`93`	`93`	`Method target = ReflectionUtils.findMethod(fragment.getClass(), method.getName(), method.getParameterTypes());`
`94`	`94`
`95`	`95`	`if (target == null) {`
`96`		`- throw new NoSuchMethodException("Method [%s] is not implemented by [%s]".formatted(method, target));`
	`96`	`+ throw new MethodNotImplementedException("Method [%s] is not implemented by [%s]".formatted(method, target));`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`try {`
`@@ -127,4 +127,11 @@ public ProjectionFactory getProjectionFactory() {`
`127`	`127`	`}`
`128`	`128`	`};`
`129`	`129`	`}`
	`130`	`+`
	`131`	`+ public static class MethodNotImplementedException extends RuntimeException {`
	`132`	`+`
	`133`	`+ public MethodNotImplementedException(String message) {`
	`134`	`+ super(message);`
	`135`	`+ }`
	`136`	`+ }`
`130`	`137`	`}`