Support of QueryByExampleExecutor#count(...).

This commit introduces the count by example method `count(...)` 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

@@ -185,4 +185,12 @@ public interface JdbcAggregateOperations {
 	 * @return {@literal true} if the object exists.
 	 */
 	<T> boolean exists(Example<T> example);
+
+	/**
+	 * Counts the number of aggregates of a given type that match the given <code>example</code>.
+	 *
+	 * @param example the example to match.
+	 * @return the number of instances stored in the database. Guaranteed to be not {@code null}.
+	 */
+	<T> long count(Example<T> example);
 }

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

@@ -287,6 +287,13 @@ public <T> boolean exists(Example<T> example) {
 		return accessStrategy.exists(query, probeType);
 	}
 
+	@Override
+	public <T> long count(Example<T> example) {
+		Query query = this.exampleMapper.getMappedExample(example);
+		Class<T> probeType = example.getProbeType();
+		return accessStrategy.count(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

@@ -226,6 +226,11 @@ 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) {
 
 		// Keep <T> as Eclipse fails to compile if <> is used.

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

@@ -258,4 +258,13 @@ Iterable<Object> findAllByPath(Identifier identifier,
 	 * @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

@@ -469,6 +469,18 @@ public <T> boolean exists(Query query, Class<T> probeType) {
 		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 <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

@@ -222,6 +222,11 @@ public <T> boolean exists(Query query, Class<T> probeType) {
 		return delegate.exists(query, probeType);
 	}
 
+	@Override
+	public <T> long count(Query query, Class<T> probeType) {
+		return delegate.count(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

@@ -745,6 +745,25 @@ public String selectByQuery(Query query, MapSqlParameterSource parameterSource)
 		return render(select);
 	}
 
+	/**
+	 * Constructs a single sql query that performs select count based on the provided query for checking existence.
+	 * 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) {
+
+		Expression idColumn = getIdColumn();
+		SelectBuilder.SelectJoin baseSelect = getSelectCountWithExpression(idColumn);
+
+		Select select = applyQueryOnSelect(query, parameterSource, (SelectBuilder.SelectWhere) baseSelect) //
+				.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>
@@ -753,11 +772,33 @@ public String selectByQuery(Query query, MapSqlParameterSource parameterSource)
 	 * @param parameterSource the source for holding the bindings
 	 * @return a non null query string.
 	 */
-	public String existsByQuery(Query query, MapSqlParameterSource parameterSource) {
-		Table table = getTable();
+	public String countByQuery(Query query, MapSqlParameterSource parameterSource) {
+
+		Expression countExpression = Expressions.just("1");
+		SelectBuilder.SelectJoin baseSelect = getSelectCountWithExpression(countExpression);
 
+		Select select = applyQueryOnSelect(query, parameterSource, (SelectBuilder.SelectWhere) baseSelect) //
+				.build();
+
+		return render(select);
+	}
+
+	/**
+	 * Generates a {@link org.springframework.data.relational.core.sql.SelectBuilder.SelectJoin} with a
+	 * <code>COUNT(...)</code> where the <code>countExpressions</code> are the parameters of the count.
+	 *
+	 * @param countExpressions the expression to use as count parameter.
+	 * @return a non-null {@link org.springframework.data.relational.core.sql.SelectBuilder.SelectJoin} that joins all the
+	 *         columns and has only a count in the projection of the select.
+	 */
+	private SelectBuilder.SelectJoin getSelectCountWithExpression(Expression... countExpressions) {
+
+		Assert.notNull(countExpressions, "countExpressions must not be null");
+		Assert.state(countExpressions.length >= 1, "countExpressions must contain at least one expression");
+
+		Table table = getTable();
 		SelectBuilder.SelectFromAndJoin selectBuilder = StatementBuilder //
-				.select(Functions.count(getIdColumn())) //
+				.select(Functions.count(countExpressions)) //
 				.from(table);//
 
 		SelectBuilder.SelectJoin baseSelect = selectBuilder;
@@ -774,11 +815,7 @@ public String existsByQuery(Query query, MapSqlParameterSource parameterSource)
 				baseSelect = baseSelect.leftOuterJoin(join.joinTable).on(join.joinColumn).equals(join.parentId);
 			}
 		}
-
-		Select select = applyQueryOnSelect(query, parameterSource, (SelectBuilder.SelectWhere) baseSelect) //
-				.build();
-
-		return render(select);
+		return baseSelect;
 	}
 
 	private SelectBuilder.SelectOrdered applyQueryOnSelect(Query query, MapSqlParameterSource parameterSource,

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

@@ -381,12 +381,20 @@ public <T> Iterable<T> select(Query query, Class<T> probeType) {
 		return null;
 	}
 
-	@Override public <T> boolean exists(Query query, Class<T> probeType) {
+	@Override
+	public <T> boolean exists(Query query, Class<T> probeType) {
 		// TODO: DIEGO find help for this one
 		// I have zero MyBatis knowledge.
 		return false;
 	}
 
+	@Override
+	public <T> long count(Query query, Class<T> probeType) {
+		// TODO: DIEGO find help for this one
+		// I have zero MyBatis knowledge.
+		return 0;
+	}
+
 	/*
 	 * (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

@@ -220,13 +220,9 @@ public <S extends T> Page<S> findAll(Example<S> example, Pageable pageable) {
 
 	@Override
 	public <S extends T> long count(Example<S> example) {
-		/*Assert.notNull(example, "Example must not be null!");
-		
-		Query query = this.exampleMapper.getMappedExample(example);
-		
-		return this.entityOperations.count(query, example.getProbeType());*/
-		// TODO: impl
-		return 0;
+		Assert.notNull(example, "Example must not be null!");
+
+		return this.entityOperations.count(example);
 	}
 
 	@Override

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

@@ -761,6 +761,28 @@ void existsByQuerySimpleValidTest() {
 				.containsOnly(entry("x_name", probe.name));
 	}
 
+	@Test
+	void countByQuerySimpleValidTest() {
+		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.countByQuery(query, parameterSource);
+		assertThat(generatedSQL) //
+				.isNotNull() //
+				.containsIgnoringCase("COUNT(1)") //
+				.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

@@ -765,6 +765,78 @@ void existsByExampleComplex() {
 		assertThat(exists).isTrue();
 	}
 
+	@Test
+	void countByExampleShouldGetOne() {
+
+		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"));
+
+		long count = repository.count(example);
+
+		assertThat(count).isOne();
+	}
+
+	@Test
+	void countByExampleMultipleMatchShouldGetOne() {
+
+		DummyEntity dummyEntity1 = createDummyEntity();
+		repository.save(dummyEntity1);
+
+		DummyEntity dummyEntity2 = createDummyEntity();
+		repository.save(dummyEntity2);
+
+		Example<DummyEntity> example = Example.of(createDummyEntity());
+
+		long count = repository.count(example);
+		assertThat(count).isEqualTo(2);
+	}
+
+	@Test
+	void countByExampleShouldGetNone() {
+
+		DummyEntity dummyEntity1 = createDummyEntity();
+		dummyEntity1.setFlag(true);
+
+		repository.save(dummyEntity1);
+
+		Example<DummyEntity> example = Example.of(new DummyEntity("NotExisting"));
+
+		long count = repository.count(example);
+
+		assertThat(count).isNotNull().isZero();
+	}
+
+	@Test
+	void countByExampleComplex() {
+
+		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);
+
+		long count = repository.count(example);
+		assertThat(count).isOne();
+	}
+
 	private Instant createDummyBeforeAndAfterNow() {
 
 		Instant now = Instant.now();