Support of QueryByExampleExecutor#exists(...).

This commit introduces the exists by example method `exists(...)` to spring-data-jdbc. MyBatis implementation is missing since I do not have the knowledge for this.

Related tickets spring-projects#1192

Author: DiegoKrupitza

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

@@ -177,4 +177,12 @@ public interface JdbcAggregateOperations {
 	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
 	 */
 	<T> Iterable<T> select(Example<T> example, Sort sort);
+
+	/**
+	 * Determine whether the result matches {@link Example}
+	 *
+	 * @param example must not be {@literal null}.
+	 * @return {@literal true} if the object exists.
+	 */
+	<T> boolean exists(Example<T> example);
 }

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

@@ -270,13 +270,23 @@ public <T> Optional<T> selectOne(Example<T> example) {
 		return accessStrategy.selectOne(query, probeType);
 	}
 
-	@Override public <T> Iterable<T> select(Example<T> example, Sort sort) {
+	@Override
+	public <T> Iterable<T> select(Example<T> example, Sort sort) {
 		Query query = this.exampleMapper.getMappedExample(example).sort(sort);
 		Class<T> probeType = example.getProbeType();
 
 		return accessStrategy.select(query, probeType);
 	}
 
+	@Override
+	public <T> boolean exists(Example<T> example) {
+		Query query = this.exampleMapper.getMappedExample(example);
+
+		Class<T> probeType = example.getProbeType();
+
+		return accessStrategy.exists(query, probeType);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.JdbcAggregateOperations#findAll(java.lang.Class)

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

@@ -221,6 +221,11 @@ public <T> Iterable<T> select(Query query, Class<T> probeType) {
 		return collect(das -> das.select(query, probeType));
 	}
 
+	@Override
+	public <T> boolean exists(Query query, Class<T> probeType) {
+		return collect(das -> das.exists(query, probeType));
+	}
+
 	private <T> T collect(Function<DataAccessStrategy, T> function) {
 
 		// Keep <T> as Eclipse fails to compile if <> is used.

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

@@ -18,7 +18,6 @@
 import java.util.Map;
 import java.util.Optional;
 
-import org.springframework.dao.DataAccessException;
 import org.springframework.dao.OptimisticLockingFailureException;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
@@ -235,6 +234,7 @@ Iterable<Object> findAllByPath(Identifier identifier,
 	 * 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.
 	 */
@@ -244,8 +244,18 @@ Iterable<Object> findAllByPath(Identifier identifier,
 	 * 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);
+
+	/**
+	 * 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);
 }

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

@@ -457,6 +457,18 @@ public <T> Iterable<T> select(Query query, Class<T> probeType) {
 		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;
+	}
+
 	private <S, T> SqlIdentifierParameterSource getParameterSource(@Nullable S instance,
 			RelationalPersistentEntity<S> persistentEntity, String prefix,
 			Predicate<RelationalPersistentProperty> skipProperty, IdentifierProcessing identifierProcessing) {

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

@@ -217,6 +217,11 @@ public <T> Iterable<T> select(Query query, Class<T> probeType) {
 		return delegate.select(query, probeType);
 	}
 
+	@Override
+	public <T> boolean exists(Query query, Class<T> probeType) {
+		return delegate.exists(query, probeType);
+	}
+
 	/**
 	 * Must be called exactly once before calling any of the other methods.
 	 *

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

@@ -737,10 +737,55 @@ public String selectByQuery(Query query, MapSqlParameterSource parameterSource)
 
 		Assert.notNull(parameterSource, "parameterSource must not be null");
 
-		Table table = Table.create(this.entity.getTableName());
-
 		SelectBuilder.SelectWhere selectBuilder = selectBuilder();
 
+		Select select = applyQueryOnSelect(query, parameterSource, selectBuilder) //
+				.build();
+
+		return render(select);
+	}
+
+	/**
+	 * Constructs a single sql query that performs select count based on the provided query. Additional the bindings for
+	 * the where clause are stored after execution into the <code>parameterSource</code>
+	 *
+	 * @param query the query to base the select on. Must not be null
+	 * @param parameterSource the source for holding the bindings
+	 * @return a non null query string.
+	 */
+	public String existsByQuery(Query query, MapSqlParameterSource parameterSource) {
+		Table table = getTable();
+
+		SelectBuilder.SelectFromAndJoin selectBuilder = StatementBuilder //
+				.select(Functions.count(getIdColumn())) //
+				.from(table);//
+
+		SelectBuilder.SelectJoin baseSelect = selectBuilder;
+
+		// add possible joins
+		for (PersistentPropertyPath<RelationalPersistentProperty> path : mappingContext
+				.findPersistentPropertyPaths(entity.getType(), p -> true)) {
+
+			PersistentPropertyPathExtension extPath = new PersistentPropertyPathExtension(mappingContext, path);
+
+			// add a join if necessary
+			Join join = getJoin(extPath);
+			if (join != null) {
+				baseSelect = baseSelect.leftOuterJoin(join.joinTable).on(join.joinColumn).equals(join.parentId);
+			}
+		}
+
+		Select select = applyQueryOnSelect(query, parameterSource, (SelectBuilder.SelectWhere) baseSelect) //
+				.build();
+
+		return render(select);
+	}
+
+	private SelectBuilder.SelectOrdered applyQueryOnSelect(Query query, MapSqlParameterSource parameterSource,
+			SelectBuilder.SelectWhere selectBuilder) {
+
+		Table table = Table.create(this.entity.getTableName());
+
 		SelectBuilder.SelectOrdered selectOrdered = query //
 				.getCriteria() //
 				.map(item -> this.applyCriteria(item, selectBuilder, parameterSource, table)) //
@@ -760,12 +805,7 @@ public String selectByQuery(Query query, MapSqlParameterSource parameterSource)
 		if (query.getOffset() > 0) {
 			limitable = limitable.offset(query.getOffset());
 		}
-
-		selectOrdered = (SelectBuilder.SelectOrdered) limitable;
-		Select select = selectOrdered //
-				.build();
-
-		return render(select);
+		return (SelectBuilder.SelectOrdered) limitable;
 	}
 
 	SelectBuilder.SelectOrdered applyCriteria(@Nullable CriteriaDefinition criteria,

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategy.java

@@ -381,6 +381,12 @@ public <T> Iterable<T> select(Query query, Class<T> probeType) {
 		return null;
 	}
 
+	@Override public <T> boolean exists(Query query, Class<T> probeType) {
+		// TODO: DIEGO find help for this one
+		// I have zero MyBatis knowledge.
+		return false;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.jdbc.core.DataAccessStrategy#count(java.lang.Class)

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/SimpleJdbcRepository.java

@@ -209,7 +209,7 @@ public <S extends T> Iterable<S> findAll(Example<S> example, Sort sort) {
 		Assert.notNull(example, "Example must not be null!");
 		Assert.notNull(sort, "Sort must not be null!");
 
-		return this.entityOperations.select(example,sort);
+		return this.entityOperations.select(example, sort);
 	}
 
 	@Override
@@ -231,14 +231,9 @@ public <S extends T> long count(Example<S> example) {
 
 	@Override
 	public <S extends T> boolean exists(Example<S> example) {
+		Assert.notNull(example, "Example must not be null!");
 
-		/*Assert.notNull(example, "Example must not be null!");
-		
-		Query query = this.exampleMapper.getMappedExample(example);
-		
-		return this.entityOperations.exists(query, example.getProbeType());*/
-		// TODO: impl
-		return false;
+		return this.entityOperations.exists(example);
 	}
 
 	@Override

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/SqlGeneratorUnitTests.java

@@ -742,6 +742,25 @@ void selectByQueryValidTest() {
 				.containsOnly(entry("x_name", probe.name));
 	}
 
+	@Test
+	void existsByQuerySimpleValidTest() {
+		final SqlGenerator sqlGenerator = createSqlGenerator(DummyEntity.class);
+
+		DummyEntity probe = new DummyEntity();
+		probe.name = "Diego";
+
+		Criteria criteria = Criteria.where("name").is(probe.name);
+		Query query = Query.query(criteria);
+
+		MapSqlParameterSource parameterSource = new MapSqlParameterSource();
+
+		String generatedSQL = sqlGenerator.existsByQuery(query, parameterSource);
+		assertThat(generatedSQL).isNotNull().contains(":x_name");
+
+		assertThat(parameterSource.getValues()) //
+				.containsOnly(entry("x_name", probe.name));
+	}
+
 	private SqlIdentifier getAlias(Object maybeAliased) {
 
 		if (maybeAliased instanceof Aliased) {

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/JdbcRepositoryIntegrationTests.java

@@ -693,6 +693,78 @@ void findAllByExampleShouldGetNone() {
 				.isEmpty();
 	}
 
+	@Test
+	void existsByExampleShouldGetOne() {
+
+		DummyEntity dummyEntity1 = createDummyEntity();
+		dummyEntity1.setFlag(true);
+
+		repository.save(dummyEntity1);
+
+		DummyEntity dummyEntity2 = createDummyEntity();
+		dummyEntity2.setName("Diego");
+
+		repository.save(dummyEntity2);
+
+		Example<DummyEntity> example = Example.of(new DummyEntity("Diego"));
+
+		boolean exists = repository.exists(example);
+
+		assertThat(exists).isTrue();
+	}
+
+	@Test
+	void existsByExampleMultipleMatchShouldGetOne() {
+
+		DummyEntity dummyEntity1 = createDummyEntity();
+		repository.save(dummyEntity1);
+
+		DummyEntity dummyEntity2 = createDummyEntity();
+		repository.save(dummyEntity2);
+
+		Example<DummyEntity> example = Example.of(createDummyEntity());
+
+		boolean exists = repository.exists(example);
+		assertThat(exists).isTrue();
+	}
+
+	@Test
+	void existsByExampleShouldGetNone() {
+
+		DummyEntity dummyEntity1 = createDummyEntity();
+		dummyEntity1.setFlag(true);
+
+		repository.save(dummyEntity1);
+
+		Example<DummyEntity> example = Example.of(new DummyEntity("NotExisting"));
+
+		boolean exists = repository.exists(example);
+
+		assertThat(exists).isFalse();
+	}
+
+	@Test
+	void existsByExampleComplex() {
+
+		final Instant pointInTime = Instant.now().minusSeconds(10000);
+
+		final DummyEntity one = repository.save(createDummyEntity());
+
+		DummyEntity two = createDummyEntity();
+		two.setName("Diego");
+		two.setPointInTime(pointInTime);
+		two = repository.save(two);
+
+		DummyEntity exampleEntitiy = createDummyEntity();
+		exampleEntitiy.setName("Diego");
+		exampleEntitiy.setPointInTime(pointInTime);
+
+		Example<DummyEntity> example = Example.of(exampleEntitiy);
+
+		boolean exists = repository.exists(example);
+		assertThat(exists).isTrue();
+	}
+
 	private Instant createDummyBeforeAndAfterNow() {
 
 		Instant now = Instant.now();