Support for Query By Example.

Original pull request #1195
Closes #1192

Author: DiegoKrupitza

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateOperations.java

@@ -15,9 +15,13 @@
  */
 package org.springframework.data.jdbc.core;
 
+import java.util.Optional;
+
+import org.springframework.data.domain.Example;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.relational.core.query.Query;
 import org.springframework.lang.Nullable;
 
 /**
@@ -27,6 +31,7 @@
  * @author Thomas Lang
  * @author Milan Milanov
  * @author Chirag Tailor
+ * @author Diego Krupitza
  */
 public interface JdbcAggregateOperations {
 
@@ -183,4 +188,54 @@ public interface JdbcAggregateOperations {
 	 * @since 2.0
 	 */
 	<T> Page<T> findAll(Class<T> domainType, Pageable pageable);
+
+	/**
+	 * Execute a {@code SELECT} query and convert the resulting item to an entity ensuring exactly one result.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param entityClass the entity type must not be {@literal null}.
+	 * @return exactly one result or {@link Optional#empty()} if no match found.
+	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+	 */
+	<T> Optional<T> selectOne(Query query, Class<T> entityClass);
+
+	/**
+	 * Execute a {@code SELECT} query and convert the resulting items to a {@link Iterable} that is sorted.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param entityClass the entity type must not be {@literal null}.
+	 * @param sort the sorting that should be used on the result.
+	 * @return a non-null sorted list with all the matching results.
+	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+	 */
+	<T> Iterable<T> select(Query query, Class<T> entityClass, Sort sort);
+
+	/**
+	 * Determine whether there are aggregates that match the {@link Query}
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param entityClass the entity type must not be {@literal null}.
+	 * @return {@literal true} if the object exists.
+	 */
+	<T> boolean exists(Query query, Class<T> entityClass);
+
+	/**
+	 * Counts the number of aggregates of a given type that match the given <code>query</code>.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param entityClass the entity type must not be {@literal null}.
+	 * @return the number of instances stored in the database. Guaranteed to be not {@code null}.
+	 */
+	<T> long count(Query query, Class<T> entityClass);
+
+	/**
+	 * Returns a {@link Page} of entities matching the given {@link Query}. In case no match could be found, an empty
+	 * {@link Page} is returned.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param entityClass the entity type must not be {@literal null}.
+	 * @param pageable can be null.
+	 * @return a {@link Page} of entities matching the given {@link Example}.
+	 */
+	<T> Page<T> select(Query query, Class<T> entityClass, Pageable pageable);
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java

@@ -20,6 +20,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
@@ -46,6 +47,7 @@
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
 import org.springframework.data.relational.core.mapping.event.*;
+import org.springframework.data.relational.core.query.Query;
 import org.springframework.data.support.PageableExecutionUtils;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -61,6 +63,7 @@
  * @author Milan Milanov
  * @author Myeonghyeon Lee
  * @author Chirag Tailor
+ * @author Diego Krupitza
  */
 public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 
@@ -71,6 +74,7 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations {
 
 	private final DataAccessStrategy accessStrategy;
 	private final AggregateChangeExecutor executor;
+
 	private final JdbcConverter converter;
 
 	private EntityCallbacks entityCallbacks = EntityCallbacks.create();
@@ -238,6 +242,38 @@ public <T> Page<T> findAll(Class<T> domainType, Pageable pageable) {
 		return PageableExecutionUtils.getPage(content, pageable, () -> accessStrategy.count(domainType));
 	}
 
+	@Override
+	public <T> Optional<T> selectOne(Query query, Class<T> entityClass) {
+		return accessStrategy.selectOne(query, entityClass);
+	}
+
+	@Override
+	public <T> Iterable<T> select(Query query, Class<T> entityClass, Sort sort) {
+		return accessStrategy.select(query, entityClass);
+	}
+
+	@Override
+	public <T> boolean exists(Query query, Class<T> entityClass) {
+		return accessStrategy.exists(query, entityClass);
+	}
+
+	@Override
+	public <T> long count(Query query, Class<T> entityClass) {
+		return accessStrategy.count(query, entityClass);
+	}
+
+	@Override
+	public <T> Page<T> select(Query query, Class<T> entityClass, Pageable pageable) {
+		Iterable<T> items = triggerAfterConvert(accessStrategy.select(query, entityClass, pageable));
+		List<T> content = StreamSupport.stream(items.spliterator(), false).collect(Collectors.toList());
+
+		return PageableExecutionUtils.getPage(content, pageable, () -> accessStrategy.count(query, entityClass));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#findAll(java.lang.Class)
+	 */
 	@Override
 	public <T> Iterable<T> findAll(Class<T> domainType) {
 

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

@@ -17,6 +17,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
@@ -25,6 +26,7 @@
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.conversion.IdValueSource;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.relational.core.query.Query;
 import org.springframework.data.relational.core.sql.LockMode;
 
 import static java.lang.Boolean.*;
@@ -39,6 +41,7 @@
  * @author Milan Milanov
  * @author Myeonghyeon Lee
  * @author Chirag Tailor
+ * @author Diego Krupitza
  * @since 1.1
  */
 public class CascadingDataAccessStrategy implements DataAccessStrategy {
@@ -160,6 +163,31 @@ public <T> Iterable<T> findAll(Class<T> domainType, Pageable pageable) {
 		return collect(das -> das.findAll(domainType, pageable));
 	}
 
+	@Override
+	public <T> Optional<T> selectOne(Query query, Class<T> probeType) {
+		return collect(das -> das.selectOne(query, probeType));
+	}
+
+	@Override
+	public <T> Iterable<T> select(Query query, Class<T> probeType) {
+		return collect(das -> das.select(query, probeType));
+	}
+
+	@Override
+	public <T> Iterable<T> select(Query query, Class<T> probeType, Pageable pageable) {
+		return collect(das -> das.select(query, probeType, pageable));
+	}
+
+	@Override
+	public <T> boolean exists(Query query, Class<T> probeType) {
+		return collect(das -> das.exists(query, probeType));
+	}
+
+	@Override
+	public <T> long count(Query query, Class<T> probeType) {
+		return collect(das -> das.count(query, probeType));
+	}
+
 	private <T> T collect(Function<DataAccessStrategy, T> function) {
 
 		return strategies.stream().collect(new FunctionCollector<>(function));

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

@@ -17,6 +17,7 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 import org.springframework.dao.OptimisticLockingFailureException;
 import org.springframework.data.domain.Pageable;
@@ -25,6 +26,7 @@
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.relational.core.conversion.IdValueSource;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.relational.core.query.Query;
 import org.springframework.data.relational.core.sql.LockMode;
 import org.springframework.lang.Nullable;
 
@@ -38,6 +40,7 @@
  * @author Milan Milanov
  * @author Myeonghyeon Lee
  * @author Chirag Tailor
+ * @author Diego Krupitza
  */
 public interface DataAccessStrategy extends RelationResolver {
 
@@ -281,4 +284,54 @@ Iterable<Object> findAllByPath(Identifier identifier,
 	 * @since 2.0
 	 */
 	<T> Iterable<T> findAll(Class<T> domainType, Pageable pageable);
+
+	/**
+	 * Execute a {@code SELECT} query and convert the resulting item to an entity ensuring exactly one result.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param probeType the type of entities. Must not be {@code null}.
+	 * @return exactly one result or {@link Optional#empty()} if no match found.
+	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+	 */
+	<T> Optional<T> selectOne(Query query, Class<T> probeType);
+
+	/**
+	 * Execute a {@code SELECT} query and convert the resulting items to a {@link Iterable}.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param probeType the type of entities. Must not be {@code null}.
+	 * @return a non-null list with all the matching results.
+	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+	 */
+	<T> Iterable<T> select(Query query, Class<T> probeType);
+
+	/**
+	 * Execute a {@code SELECT} query and convert the resulting items to a {@link Iterable}. Applies the {@link Pageable}
+	 * to the result.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param probeType the type of entities. Must not be {@literal  null}.
+	 * @param pageable the pagination that should be applied. Must not be {@literal null}.
+	 * @return a non-null list with all the matching results.
+	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+	 */
+	<T> Iterable<T> select(Query query, Class<T> probeType, Pageable pageable);
+
+	/**
+	 * Determine whether there is an aggregate of type <code>probeType</code> that matches the provided {@link Query}.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param probeType the type of entities. Must not be {@code null}.
+	 * @return {@literal true} if the object exists.
+	 */
+	<T> boolean exists(Query query, Class<T> probeType);
+
+	/**
+	 * Counts the rows in the table representing the given probe type, that match the given <code>query</code>.
+	 *
+	 * @param probeType the probe type for which to count the elements. Must not be {@code null}.
+	 * @param query the query which elements have to match.
+	 * @return the count. Guaranteed to be not {@code null}.
+	 */
+	<T> long count(Query query, Class<T> probeType);
 }

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

@@ -20,7 +20,9 @@
 import java.sql.ResultSet;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.function.Predicate;
 
 import org.springframework.dao.EmptyResultDataAccessException;
 import org.springframework.dao.OptimisticLockingFailureException;
@@ -32,10 +34,12 @@
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.relational.core.query.Query;
 import org.springframework.data.relational.core.sql.IdentifierProcessing;
 import org.springframework.data.relational.core.sql.LockMode;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
 import org.springframework.jdbc.core.RowMapper;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
 import org.springframework.jdbc.core.namedparam.SqlParameterSource;
 import org.springframework.lang.Nullable;
@@ -56,6 +60,7 @@
  * @author Yunyoung LEE
  * @author Radim Tlusty
  * @author Chirag Tailor
+ * @author Diego Krupitza
  * @since 1.1
  */
 public class DefaultDataAccessStrategy implements DataAccessStrategy {
@@ -336,6 +341,61 @@ public <T> Iterable<T> findAll(Class<T> domainType, Pageable pageable) {
 		return operations.query(sql(domainType).getFindAll(pageable), (RowMapper<T>) getEntityRowMapper(domainType));
 	}
 
+	@Override
+	public <T> Optional<T> selectOne(Query query, Class<T> probeType) {
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+		String sqlQuery = sql(probeType).selectByQuery(query, parameterSource);
+
+		T foundObject;
+		try {
+			foundObject = operations.queryForObject(sqlQuery, parameterSource, (RowMapper<T>) getEntityRowMapper(probeType));
+		} catch (EmptyResultDataAccessException e) {
+			foundObject = null;
+		}
+
+		return Optional.ofNullable(foundObject);
+	}
+
+	@Override
+	public <T> Iterable<T> select(Query query, Class<T> probeType) {
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+		String sqlQuery = sql(probeType).selectByQuery(query, parameterSource);
+
+		return operations.query(sqlQuery, parameterSource, (RowMapper<T>) getEntityRowMapper(probeType));
+	}
+
+	@Override
+	public <T> Iterable<T> select(Query query, Class<T> probeType, Pageable pageable) {
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+		String sqlQuery = sql(probeType).selectByQuery(query, parameterSource, pageable);
+
+		return operations.query(sqlQuery, parameterSource, (RowMapper<T>) getEntityRowMapper(probeType));
+	}
+
+	@Override
+	public <T> boolean exists(Query query, Class<T> probeType) {
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+
+		String sqlQuery = sql(probeType).existsByQuery(query, parameterSource);
+
+		Boolean result = operations.queryForObject(sqlQuery, parameterSource, Boolean.class);
+		Assert.notNull(result, "The result of an exists query must not be null");
+
+		return result;
+	}
+
+	@Override
+	public <T> long count(Query query, Class<T> probeType) {
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+		String sqlQuery = sql(probeType).countByQuery(query, parameterSource);
+
+		Long result = operations.queryForObject(sqlQuery, parameterSource, Long.class);
+
+		Assert.notNull(result, "The result of a count query must not be null.");
+
+		return result;
+	}
+
 	private EntityRowMapper<?> getEntityRowMapper(Class<?> domainType) {
 		return new EntityRowMapper<>(getRequiredPersistentEntity(domainType), converter);
 	}