Add support for projection and Stream queries.

We now support projections on repository query methods and query methods returning a Stream.

interface PersonRepository extends LdapRepository<Person> {

	Stream<PersonProjection> streamAllByLastName(String lastName);

	PersonProjection findByLastName(String lastname);

	<T> T findByLastName(String lastname, Class<T> projection);

}

Closes #275

Author: mp911de

src/main/asciidoc/new-features.adoc

@@ -1,6 +1,11 @@
 [[new-features]]
 = New and Noteworthy
 
+[[new-features.2.6]]
+== What's New in Spring Data LDAP 2.6
+* <<repositories.query-streaming,Repository query methods returning a `Stream`>> from the underlying result `List`.
+* <<projections,Interface and DTO projections returned by query methods>>.
+
 [[new-features.2.1]]
 == What's New in Spring Data LDAP 2.1
 * CDI extension to create LDAP repositories within a CDI container.

src/main/asciidoc/reference/ldap-repositories.adoc

@@ -224,6 +224,7 @@ The following table provides samples of the keywords that you can use with query
 
 |===
 
+include::../{spring-data-commons-docs}/repository-projections.adoc[leveloffset=+2]
 
 === QueryDSL Support
 Basic QueryDSL support is included in Spring LDAP. This support includes the following:

src/main/java/org/springframework/data/ldap/repository/query/AbstractLdapRepositoryQuery.java

@@ -15,10 +15,17 @@
  */
 package org.springframework.data.ldap.repository.query;
 
-import org.springframework.dao.EmptyResultDataAccessException;
+import static org.springframework.data.ldap.repository.query.LdapQueryExecution.*;
+
+import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.ldap.repository.Query;
+import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.mapping.PersistentProperty;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mapping.model.EntityInstantiators;
 import org.springframework.data.repository.query.QueryMethod;
 import org.springframework.data.repository.query.RepositoryQuery;
+import org.springframework.data.repository.query.ResultProcessor;
 import org.springframework.ldap.core.LdapOperations;
 import org.springframework.ldap.query.LdapQuery;
 import org.springframework.util.Assert;
@@ -34,6 +41,8 @@ public abstract class AbstractLdapRepositoryQuery implements RepositoryQuery {
 	private final LdapQueryMethod queryMethod;
 	private final Class<?> entityType;
 	private final LdapOperations ldapOperations;
+	private final MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> mappingContext;
+	private final EntityInstantiators instantiators;
 
 	/**
 	 * Creates a new {@link AbstractLdapRepositoryQuery} instance given {@link LdapQuery}, {@link Class} and
@@ -42,8 +51,12 @@ public abstract class AbstractLdapRepositoryQuery implements RepositoryQuery {
 	 * @param queryMethod must not be {@literal null}.
 	 * @param entityType must not be {@literal null}.
 	 * @param ldapOperations must not be {@literal null}.
+	 * @param mappingContext must not be {@literal null}.
+	 * @param instantiators must not be {@literal null}.
 	 */
-	public AbstractLdapRepositoryQuery(LdapQueryMethod queryMethod, Class<?> entityType, LdapOperations ldapOperations) {
+	public AbstractLdapRepositoryQuery(LdapQueryMethod queryMethod, Class<?> entityType, LdapOperations ldapOperations,
+			MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> mappingContext,
+			EntityInstantiators instantiators) {
 
 		Assert.notNull(queryMethod, "LdapQueryMethod must not be null!");
 		Assert.notNull(entityType, "Entity type must not be null!");
@@ -52,6 +65,8 @@ public AbstractLdapRepositoryQuery(LdapQueryMethod queryMethod, Class<?> entityT
 		this.queryMethod = queryMethod;
 		this.entityType = entityType;
 		this.ldapOperations = ldapOperations;
+		this.mappingContext = mappingContext;
+		this.instantiators = instantiators;
 	}
 
 	/* (non-Javadoc)
@@ -61,16 +76,28 @@ public AbstractLdapRepositoryQuery(LdapQueryMethod queryMethod, Class<?> entityT
 	@SuppressWarnings("ConstantConditions")
 	public final Object execute(Object[] parameters) {
 
-		LdapQuery query = createQuery(parameters);
+		LdapParametersParameterAccessor parameterAccessor = new LdapParametersParameterAccessor(queryMethod, parameters);
+		LdapQuery query = createQuery(parameterAccessor);
+
+		ResultProcessor processor = queryMethod.getResultProcessor().withDynamicProjection(parameterAccessor);
+		Class<?> typeToRead = processor.getReturnedType().getDomainType();
+
+		ResultProcessingConverter converter = new ResultProcessingConverter(processor, mappingContext, instantiators);
+		ResultProcessingExecution execution = new ResultProcessingExecution(
+				getLdapQueryExecutionToWrap(typeToRead, converter), converter);
+
+		return execution.execute(query);
+	}
+
+	private LdapQueryExecution getLdapQueryExecutionToWrap(Class<?> typeToRead,
+			Converter<Object, Object> resultProcessing) {
 
 		if (queryMethod.isCollectionQuery()) {
-			return ldapOperations.find(query, entityType);
+			return new CollectionExecution(ldapOperations, typeToRead);
+		} else if (queryMethod.isStreamQuery()) {
+			return new StreamExecution(ldapOperations, typeToRead, resultProcessing);
 		} else {
-			try {
-				return ldapOperations.findOne(query, entityType);
-			} catch (EmptyResultDataAccessException e) {
-				return null;
-			}
+			return new FindOneExecution(ldapOperations, typeToRead);
 		}
 	}
 
@@ -80,7 +107,7 @@ public final Object execute(Object[] parameters) {
 	 * @param parameters must not be {@literal null}.
 	 * @return
 	 */
-	protected abstract LdapQuery createQuery(Object[] parameters);
+	protected abstract LdapQuery createQuery(LdapParameterAccessor parameters);
 
 	/**
 	 * @return

src/main/java/org/springframework/data/ldap/repository/query/AnnotatedLdapRepositoryQuery.java

@@ -18,6 +18,10 @@
 import static org.springframework.ldap.query.LdapQueryBuilder.*;
 
 import org.springframework.data.ldap.repository.Query;
+import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.mapping.PersistentProperty;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mapping.model.EntityInstantiators;
 import org.springframework.ldap.core.LdapOperations;
 import org.springframework.ldap.query.LdapQuery;
 import org.springframework.util.Assert;
@@ -38,10 +42,14 @@ public class AnnotatedLdapRepositoryQuery extends AbstractLdapRepositoryQuery {
 	 * @param queryMethod the QueryMethod.
 	 * @param entityType the managed class.
 	 * @param ldapOperations the LdapOperations instance to use.
+	 * @param mappingContext must not be {@literal null}.
+	 * @param instantiators must not be {@literal null}.
 	 */
-	public AnnotatedLdapRepositoryQuery(LdapQueryMethod queryMethod, Class<?> entityType, LdapOperations ldapOperations) {
+	public AnnotatedLdapRepositoryQuery(LdapQueryMethod queryMethod, Class<?> entityType, LdapOperations ldapOperations,
+			MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> mappingContext,
+			EntityInstantiators instantiators) {
 
-		super(queryMethod, entityType, ldapOperations);
+		super(queryMethod, entityType, ldapOperations, mappingContext, instantiators);
 
 		Assert.notNull(queryMethod.getQueryAnnotation(), "Annotation must be present");
 		Assert.hasLength(queryMethod.getQueryAnnotation().value(), "Query filter must be specified");
@@ -50,15 +58,15 @@ public AnnotatedLdapRepositoryQuery(LdapQueryMethod queryMethod, Class<?> entity
 	}
 
 	/* (non-Javadoc)
-	 * @see org.springframework.data.ldap.repository.query.AbstractLdapRepositoryQuery#createQuery(java.lang.Object[])
+	 * @see org.springframework.data.ldap.repository.query.AbstractLdapRepositoryQuery#createQuery(org.springframework.data.ldap.repository.query.LdapParameterAccessor)
 	 */
 	@Override
-	protected LdapQuery createQuery(Object[] parameters) {
+	protected LdapQuery createQuery(LdapParameterAccessor parameters) {
 
 		return query().base(queryAnnotation.base()) //
 				.searchScope(queryAnnotation.searchScope()) //
 				.countLimit(queryAnnotation.countLimit()) //
 				.timeLimit(queryAnnotation.timeLimit()) //
-				.filter(queryAnnotation.value(), parameters);
+				.filter(queryAnnotation.value(), parameters.getBindableParameterValues());
 	}
 }

src/main/java/org/springframework/data/ldap/repository/query/LdapParameterAccessor.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2021 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
+ *
+ *      http://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.ldap.repository.query;
+
+import org.springframework.data.repository.query.ParameterAccessor;
+
+/**
+ * LDAP-specific {@link ParameterAccessor} exposing all bindable parameters.
+ *
+ * @author Mark Paluch
+ * @since 2.6
+ */
+interface LdapParameterAccessor extends ParameterAccessor {
+
+	/**
+	 * Returns the bindable parameter values of the underlying query method.
+	 *
+	 * @return
+	 */
+	Object[] getBindableParameterValues();
+}

src/main/java/org/springframework/data/ldap/repository/query/LdapParametersParameterAccessor.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2021 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
+ *
+ *      http://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.ldap.repository.query;
+
+import org.springframework.data.repository.query.Parameters;
+import org.springframework.data.repository.query.ParametersParameterAccessor;
+import org.springframework.data.repository.query.QueryMethod;
+
+/**
+ * LDAP-specific {@link ParametersParameterAccessor}.
+ *
+ * @author Mark Paluch
+ * @since 2.6
+ */
+class LdapParametersParameterAccessor extends ParametersParameterAccessor implements LdapParameterAccessor {
+
+	/**
+	 * Creates a new {@link LdapParametersParameterAccessor}.
+	 *
+	 * @param method must not be {@literal null}.
+	 * @param values must not be {@literal null}.
+	 */
+	public LdapParametersParameterAccessor(QueryMethod method, Object[] values) {
+		super(method.getParameters(), values);
+	}
+
+	@Override
+	public Object[] getBindableParameterValues() {
+
+		Parameters<?, ?> bindableParameters = getParameters().getBindableParameters();
+		int count = bindableParameters.getNumberOfParameters();
+
+		if (count == 0) {
+			return new Object[0];
+		}
+
+		Object[] values = new Object[count];
+
+		for (int i = 0; i < count; i++) {
+			values[i] = getBindableValue(i);
+		}
+
+		return values;
+	}
+
+}

src/main/java/org/springframework/data/ldap/repository/query/LdapQueryCreator.java

@@ -18,12 +18,11 @@
 import static org.springframework.ldap.query.LdapQueryBuilder.*;
 
 import java.util.Iterator;
+import java.util.List;
 
 import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.mapping.PropertyPath;
-import org.springframework.data.repository.query.Parameters;
-import org.springframework.data.repository.query.ParametersParameterAccessor;
 import org.springframework.data.repository.query.parser.AbstractQueryCreator;
 import org.springframework.data.repository.query.parser.Part;
 import org.springframework.data.repository.query.parser.PartTree;
@@ -45,26 +44,28 @@ class LdapQueryCreator extends AbstractQueryCreator<LdapQuery, ContainerCriteria
 
 	private final Class<?> entityType;
 	private final ObjectDirectoryMapper mapper;
+	private final List<String> inputProperties;
 
 	/**
 	 * Constructs a new {@link LdapQueryCreator}.
 	 *
 	 * @param tree must not be {@literal null}.
-	 * @param parameters must not be {@literal null}.
 	 * @param entityType must not be {@literal null}.
 	 * @param mapper must not be {@literal null}.
 	 * @param values must not be {@literal null}.
+	 * @param inputProperties must not be {@literal null}.
 	 */
-	LdapQueryCreator(PartTree tree, Parameters<?, ?> parameters, Class<?> entityType, ObjectDirectoryMapper mapper,
-			Object[] values) {
+	LdapQueryCreator(PartTree tree, Class<?> entityType, ObjectDirectoryMapper mapper,
+			LdapParameterAccessor parameterAccessor, List<String> inputProperties) {
 
-		super(tree, new ParametersParameterAccessor(parameters, values));
+		super(tree, parameterAccessor);
 
 		Assert.notNull(entityType, "Entity type must not be null!");
 		Assert.notNull(mapper, "ObjectDirectoryMapper must not be null!");
 
 		this.entityType = entityType;
 		this.mapper = mapper;
+		this.inputProperties = inputProperties;
 	}
 
 	/* (non-Javadoc)
@@ -81,6 +82,10 @@ protected ContainerCriteria create(Part part, Iterator<Object> iterator) {
 			query = query.base(entry.base());
 		}
 
+		if (!inputProperties.isEmpty()) {
+			query.attributes(inputProperties.toArray(new String[0]));
+		}
+
 		ConditionCriteria criteria = query.where(getAttribute(part));
 
 		return appendCondition(part, iterator, criteria);