Introduce Stream variant methods for SqlQuery

Closes GH-34474

Signed-off-by: Yanming Zhou <[email protected]>

Author: quaff

spring-jdbc/src/main/java/org/springframework/jdbc/object/SqlQuery.java

@@ -18,6 +18,7 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import javax.sql.DataSource;
 
@@ -52,6 +53,7 @@
  * @author Rod Johnson
  * @author Juergen Hoeller
  * @author Thomas Risberg
+ * @author Yanming Zhou
  * @param <T> the result type
  * @see SqlUpdate
  */
@@ -94,6 +96,23 @@ public List<T> execute(Object @Nullable [] params, @Nullable Map<?, ?> context)
 		return getJdbcTemplate().query(newPreparedStatementCreator(params), rowMapper);
 	}
 
+	/**
+	 * Central execution method for Stream. All un-named parameter execution goes through this method.
+	 * @param params parameters, similar to JDO query parameters.
+	 * Primitive parameters must be represented by their Object wrapper type.
+	 * The ordering of parameters is significant.
+	 * @param context the contextual information passed to the {@code mapRow}
+	 * callback method. The JDBC operation itself doesn't rely on this parameter,
+	 * but it can be useful for creating the objects of the result list.
+	 * @return a result Stream of objects, one per row of the ResultSet. Normally all these
+	 * will be of the same class, although it is possible to use different types.
+	 */
+	public Stream<T> executeForStream(Object @Nullable [] params, @Nullable Map<?, ?> context) throws DataAccessException {
+		validateParameters(params);
+		RowMapper<T> rowMapper = newRowMapper(params, context);
+		return getJdbcTemplate().queryForStream(newPreparedStatementCreator(params), rowMapper);
+	}
+
 	/**
 	 * Convenient method to execute without context.
 	 * @param params parameters for the query. Primitive parameters must
@@ -104,6 +123,16 @@ public List<T> execute(Object... params) throws DataAccessException {
 		return execute(params, null);
 	}
 
+	/**
+	 * Convenient method to execute for Stream without context.
+	 * @param params parameters for the query. Primitive parameters must
+	 * be represented by their Object wrapper type. The ordering of parameters is
+	 * significant.
+	 */
+	public Stream<T> executeForStream(Object... params) throws DataAccessException {
+		return executeForStream(params, null);
+	}
+
 	/**
 	 * Convenient method to execute without parameters.
 	 * @param context the contextual information for object creation
@@ -112,13 +141,28 @@ public List<T> execute(Map<?, ?> context) throws DataAccessException {
 		return execute((Object[]) null, context);
 	}
 
+	/**
+	 * Convenient method to execute for Stream without parameters.
+	 * @param context the contextual information for object creation
+	 */
+	public Stream<T> executeForStream(Map<?, ?> context) throws DataAccessException {
+		return executeForStream((Object[]) null, context);
+	}
+
 	/**
 	 * Convenient method to execute without parameters nor context.
 	 */
 	public List<T> execute() throws DataAccessException {
 		return execute((Object[]) null, null);
 	}
 
+	/**
+	 * Convenient method to execute for Stream without parameters nor context.
+	 */
+	public Stream<T> executeForStream() throws DataAccessException {
+		return executeForStream((Object[]) null, null);
+	}
+
 	/**
 	 * Convenient method to execute with a single int parameter and context.
 	 * @param p1 single int parameter

spring-jdbc/src/test/java/org/springframework/jdbc/object/SqlQueryTests.java

@@ -26,6 +26,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import javax.sql.DataSource;
 
@@ -52,6 +53,7 @@
  * @author Trevor Cook
  * @author Thomas Risberg
  * @author Juergen Hoeller
+ * @author Yanming Zhou
  */
 class SqlQueryTests {
 
@@ -125,6 +127,32 @@ protected Integer mapRow(ResultSet rs, int rownum, Object @Nullable [] params, @
 		verify(preparedStatement).close();
 	}
 
+	@Test
+	void testQueryForStreamWithoutParams() throws SQLException {
+		given(resultSet.next()).willReturn(true, false);
+		given(resultSet.getInt(1)).willReturn(1);
+
+		SqlQuery<Integer> query = new MappingSqlQueryWithParameters<>() {
+			@Override
+			protected Integer mapRow(ResultSet rs, int rownum, Object @Nullable [] params, @Nullable Map<? ,?> context)
+					throws SQLException {
+				assertThat(params).as("params were null").isNull();
+				assertThat(context).as("context was null").isNull();
+				return rs.getInt(1);
+			}
+		};
+		query.setDataSource(dataSource);
+		query.setSql(SELECT_ID);
+		query.compile();
+		try (Stream<Integer> stream = query.executeForStream()) {
+			List<Integer> list = stream.toList();
+			assertThat(list).containsExactly(1);
+		}
+		verify(connection).prepareStatement(SELECT_ID);
+		verify(resultSet).close();
+		verify(preparedStatement).close();
+	}
+
 	@Test
 	void testQueryWithoutEnoughParams() {
 		MappingSqlQuery<Integer> query = new MappingSqlQuery<>() {