DATAJPA-1657 - Return ResultSets from @procedure with or without cursor

javax.persistence.StoredProcedureQuery.execute method tells us if a ResultSet is being returned or not. This is the key to finally decide what to return: Output parameter values or javax.persistence.StoredProcedureQuery.getResultList(). I added a logic to return single entities from it if the method annotated with @procedure does not have a Collection return type. 

When registering the procedure output parameters I needed to find a way to predict if the user is intending to return a ResultSet or not. I ended up doing it with this condition: If the method annotated with @procedure has a collection return type or it doesn't have a collection but it has an entity return type then I know for sure that a ResultSet is intended to be returned because regular output parameters are NEVER returned in collections but in arrays (Object[]) and also regular output parameters don't return entities, but primitive types.

Author: GabrielBB

src/main/java/org/springframework/data/jpa/repository/query/JpaQueryExecution.java

@@ -53,6 +53,7 @@
  * @author Christoph Strobl
  * @author Nicolas Cirigliano
  * @author Jens Schauder
+ * @author Gabriel Basilio
  */
 public abstract class JpaQueryExecution {
 
@@ -313,7 +314,24 @@ protected Object doExecute(AbstractJpaQuery jpaQuery, JpaParametersParameterAcce
 
 			StoredProcedureJpaQuery storedProcedureJpaQuery = (StoredProcedureJpaQuery) jpaQuery;
 			StoredProcedureQuery storedProcedure = storedProcedureJpaQuery.createQuery(accessor);
-			storedProcedure.execute();
+
+			boolean returnsResultSet = storedProcedure.execute();
+
+			if (returnsResultSet) {
+				if (!SurroundingTransactionDetectorMethodInterceptor.INSTANCE.isSurroundingTransactionActive())
+					throw new InvalidDataAccessApiUsageException(NO_SURROUNDING_TRANSACTION);
+
+				List<?> result = storedProcedure.getResultList();
+
+				if (!storedProcedureJpaQuery.getQueryMethod().isCollectionQuery()) {
+					if (result.isEmpty())
+						return null;
+					if (result.size() == 1)
+						return result.get(0);
+				}
+
+				return result;
+			}
 
 			return storedProcedureJpaQuery.extractOutputValue(storedProcedure);
 		}

src/main/java/org/springframework/data/jpa/repository/query/StoredProcedureJpaQuery.java

@@ -23,6 +23,7 @@
 import javax.persistence.EntityManager;
 import javax.persistence.NamedStoredProcedureQuery;
 import javax.persistence.ParameterMode;
+import javax.persistence.StoredProcedureParameter;
 import javax.persistence.StoredProcedureQuery;
 import javax.persistence.TypedQuery;
 
@@ -132,42 +133,32 @@ Object extractOutputValue(StoredProcedureQuery storedProcedureQuery) {
 			return null;
 		}
 
-		Map<String, Object> outputValues = new HashMap<>();
-		List<String> parameterNames = procedureAttributes.getOutputParameterNames();
-
-		for (int i = 0; i < parameterNames.size(); i++) {
+		List<ProcedureParameter> outputParameters = procedureAttributes.getOutputProcedureParameters();
 
-			String name = parameterNames.get(i);
-			outputValues.put(name, extractOutputParameter(storedProcedureQuery, i));
+		if (outputParameters.size() == 1) {
+			return extractOutputParameterValue(outputParameters.get(0), 0, storedProcedureQuery);
 		}
 
-		return outputValues.size() == 1 ? outputValues.values().iterator().next() : outputValues;
-	}
-
-	private Object extractOutputParameter(StoredProcedureQuery storedProcedureQuery, Integer index) {
+		Map<String, Object> outputValues = new HashMap<>();
 
-		String outputParameterName = procedureAttributes.getOutputParameterNames().get(index);
-		JpaParameters parameters = getQueryMethod().getParameters();
+		for (int i = 0; i < outputParameters.size(); i++) {
+			ProcedureParameter outputParameter = outputParameters.get(i);
+			outputValues.put(outputParameter.getName(), extractOutputParameterValue(outputParameter, i, storedProcedureQuery));
+		}
 
-		return extractOutputParameterValue(storedProcedureQuery, outputParameterName, index,
-				parameters.getNumberOfParameters());
+		return outputValues;
 	}
 
 	/**
-	 * extract the value of an output parameter either by name or by index.
-	 *
-	 * @param storedProcedureQuery the query object of the stored procedure.
-	 * @param name the name of the output parameter
-	 * @param index index of the output parameter
-	 * @param offset for index based access the index after which to find the output parameter values
-	 * @return the value
+	 * @return The value of an output parameter either by name or by index.
 	 */
-	private Object extractOutputParameterValue(StoredProcedureQuery storedProcedureQuery, String name, Integer index,
-			int offset) {
+	private Object extractOutputParameterValue(ProcedureParameter outputParameter, Integer index, StoredProcedureQuery storedProcedureQuery) {
+
+		JpaParameters methodParameters = getQueryMethod().getParameters();
 
-		return useNamedParameters && StringUtils.hasText(name) ? //
-				storedProcedureQuery.getOutputParameterValue(name)
-				: storedProcedureQuery.getOutputParameterValue(offset + index + 1);
+		return useNamedParameters && StringUtils.hasText(outputParameter.getName()) ?
+				storedProcedureQuery.getOutputParameterValue(outputParameter.getName())
+				: storedProcedureQuery.getOutputParameterValue(methodParameters.getNumberOfParameters() + index + 1);
 	}
 
 	/**
@@ -192,9 +183,7 @@ private StoredProcedureQuery newNamedStoredProcedureQuery() {
 	private StoredProcedureQuery newAdhocStoredProcedureQuery() {
 
 		JpaParameters params = getQueryMethod().getParameters();
-		String procedureName = procedureAttributes.getProcedureName();
-
-		StoredProcedureQuery procedureQuery = getEntityManager().createStoredProcedureQuery(procedureName);
+		StoredProcedureQuery procedureQuery = createAdhocStoredProcedureQuery();
 
 		for (JpaParameter param : params) {
 
@@ -214,23 +203,41 @@ private StoredProcedureQuery newAdhocStoredProcedureQuery() {
 
 		if (procedureAttributes.hasReturnValue()) {
 
-			ParameterMode mode = ParameterMode.OUT;
+			ProcedureParameter procedureOutput = procedureAttributes.getOutputProcedureParameters().get(0);
 
-			IntStream.range(0, procedureAttributes.getOutputParameterTypes().size()).forEach(i -> {
-				Class<?> outputParameterType = procedureAttributes.getOutputParameterTypes().get(i);
+			/* If the stored procedure returns a ResultSet without using REF_CURSOR,
+				it is not necessary to declare an output parameter */
+			if ((isResultSetProcedure() && procedureOutput.getMode() == ParameterMode.REF_CURSOR) || !isResultSetProcedure()) {
 
 				if (useNamedParameters) {
-
-					String outputParameterName = procedureAttributes.getOutputParameterNames().get(i);
-					procedureQuery.registerStoredProcedureParameter(outputParameterName, outputParameterType, mode);
-
+					procedureQuery.registerStoredProcedureParameter(procedureOutput.getName(), procedureOutput.getType(), procedureOutput.getMode());
 				} else {
-					procedureQuery.registerStoredProcedureParameter(params.getNumberOfParameters() + i + 1, outputParameterType,
-							mode);
+					// Output parameter should be after the input parameters
+					int outputParameterIndex = params.getNumberOfParameters() + 1;
+					procedureQuery.registerStoredProcedureParameter(outputParameterIndex, procedureOutput.getType(),
+							procedureOutput.getMode());
 				}
-			});
+			}
 		}
 
 		return procedureQuery;
 	}
+
+	private StoredProcedureQuery createAdhocStoredProcedureQuery() {
+		String procedureName = procedureAttributes.getProcedureName();
+
+		if (getQueryMethod().isQueryForEntity()) {
+			return getEntityManager().createStoredProcedureQuery(procedureName,
+					getQueryMethod().getEntityInformation().getJavaType());
+		}
+
+		return getEntityManager().createStoredProcedureQuery(procedureName);
+	}
+
+	/**
+	 * @return true if the stored procedure will use a ResultSet to return data and not output parameters
+	 */
+	private boolean isResultSetProcedure() {
+		return getQueryMethod().isCollectionQuery() || getQueryMethod().isQueryForEntity();
+	}
 }