Avoid NPE for anonymous SqlParameter in CallMetaDataContext

jhoeller · jhoeller · commit d1f5ee2643a9 · 2015-11-14T23:15:06.000+01:00
Issue: SPR-13628 (cherry picked from commit 6685c78)
diff --git a/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java b/spring-jdbc/src/main/java/org/springframework/jdbc/core/metadata/CallMetaDataContext.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -280,88 +280,94 @@ public void processParameters(List<SqlParameter> parameters) {
 	 * Reconcile the provided parameters with available metadata and add new ones where appropriate.
 	 */
 	protected List<SqlParameter> reconcileParameters(List<SqlParameter> parameters) {
-		final List<SqlParameter> declaredReturnParameters = new ArrayList<SqlParameter>();
-		final Map<String, SqlParameter> declaredParameters = new LinkedHashMap<String, SqlParameter>();
+		final List<SqlParameter> declaredReturnParams = new ArrayList<SqlParameter>();
+		final Map<String, SqlParameter> declaredParams = new LinkedHashMap<String, SqlParameter>();
 		boolean returnDeclared = false;
-		List<String> outParameterNames = new ArrayList<String>();
-		List<String> metaDataParameterNames = new ArrayList<String>();
+		List<String> outParamNames = new ArrayList<String>();
+		List<String> metaDataParamNames = new ArrayList<String>();
 
 		// Get the names of the meta data parameters
 		for (CallParameterMetaData meta : this.metaDataProvider.getCallParameterMetaData()) {
 			if (meta.getParameterType() != DatabaseMetaData.procedureColumnReturn) {
-				metaDataParameterNames.add(meta.getParameterName().toLowerCase());
+				metaDataParamNames.add(meta.getParameterName().toLowerCase());
 			}
 		}
 
 		// Separate implicit return parameters from explicit parameters...
-		for (SqlParameter parameter : parameters) {
-			if (parameter.isResultsParameter()) {
-				declaredReturnParameters.add(parameter);
+		for (SqlParameter param : parameters) {
+			if (param.isResultsParameter()) {
+				declaredReturnParams.add(param);
 			}
 			else {
-				String parameterNameToMatch = this.metaDataProvider.parameterNameToUse(parameter.getName()).toLowerCase();
-				declaredParameters.put(parameterNameToMatch, parameter);
-				if (parameter instanceof SqlOutParameter) {
-					outParameterNames.add(parameter.getName());
-					if (isFunction() && !metaDataParameterNames.contains(parameterNameToMatch)) {
+				String paramName = param.getName();
+				if (paramName == null) {
+					throw new IllegalArgumentException("Anonymous parameters not supported for calls - " +
+							"please specify a name for the parameter of SQL type " + param.getSqlType());
+				}
+				String paramNameToMatch = this.metaDataProvider.parameterNameToUse(paramName).toLowerCase();
+				declaredParams.put(paramNameToMatch, param);
+				if (param instanceof SqlOutParameter) {
+					outParamNames.add(paramName);
+					if (isFunction() && !metaDataParamNames.contains(paramNameToMatch)) {
 						if (!returnDeclared) {
 							if (logger.isDebugEnabled()) {
-								logger.debug("Using declared out parameter '" + parameter.getName() + "' for function return value");
+								logger.debug("Using declared out parameter '" + paramName +
+										"' for function return value");
 							}
-							setFunctionReturnName(parameter.getName());
+							setFunctionReturnName(paramName);
 							returnDeclared = true;
 						}
 					}
 				}
 			}
 		}
-		setOutParameterNames(outParameterNames);
+		setOutParameterNames(outParamNames);
 
-		List<SqlParameter> workParameters = new ArrayList<SqlParameter>();
-		workParameters.addAll(declaredReturnParameters);
+		List<SqlParameter> workParams = new ArrayList<SqlParameter>();
+		workParams.addAll(declaredReturnParams);
 
 		if (!this.metaDataProvider.isProcedureColumnMetaDataUsed()) {
-			workParameters.addAll(declaredParameters.values());
-			return workParameters;
+			workParams.addAll(declaredParams.values());
+			return workParams;
 		}
 
 		Map<String, String> limitedInParamNamesMap = new HashMap<String, String>(this.limitedInParameterNames.size());
-		for (String limitedParameterName : this.limitedInParameterNames) {
+		for (String limitedParamName : this.limitedInParameterNames) {
 			limitedInParamNamesMap.put(
-					this.metaDataProvider.parameterNameToUse(limitedParameterName).toLowerCase(), limitedParameterName);
+					this.metaDataProvider.parameterNameToUse(limitedParamName).toLowerCase(), limitedParamName);
 		}
 
 		for (CallParameterMetaData meta : this.metaDataProvider.getCallParameterMetaData()) {
-			String parNameToCheck = null;
+			String paramNameToCheck = null;
 			if (meta.getParameterName() != null) {
-				parNameToCheck = this.metaDataProvider.parameterNameToUse(meta.getParameterName()).toLowerCase();
+				paramNameToCheck = this.metaDataProvider.parameterNameToUse(meta.getParameterName()).toLowerCase();
 			}
-			String parNameToUse = this.metaDataProvider.parameterNameToUse(meta.getParameterName());
-			if (declaredParameters.containsKey(parNameToCheck) ||
+			String paramNameToUse = this.metaDataProvider.parameterNameToUse(meta.getParameterName());
+			if (declaredParams.containsKey(paramNameToCheck) ||
 					(meta.getParameterType() == DatabaseMetaData.procedureColumnReturn && returnDeclared)) {
-				SqlParameter parameter;
+				SqlParameter param;
 				if (meta.getParameterType() == DatabaseMetaData.procedureColumnReturn) {
-					parameter = declaredParameters.get(getFunctionReturnName());
-					if (parameter == null && getOutParameterNames().size() > 0) {
-						parameter = declaredParameters.get(getOutParameterNames().get(0).toLowerCase());
+					param = declaredParams.get(getFunctionReturnName());
+					if (param == null && getOutParameterNames().size() > 0) {
+						param = declaredParams.get(getOutParameterNames().get(0).toLowerCase());
 					}
-					if (parameter == null) {
+					if (param == null) {
 						throw new InvalidDataAccessApiUsageException(
 								"Unable to locate declared parameter for function return value - " +
-								" add a SqlOutParameter with name \"" + getFunctionReturnName() +"\"");
+								" add a SqlOutParameter with name '" + getFunctionReturnName() + "'");
 					}
 					else {
-						setFunctionReturnName(parameter.getName());
+						setFunctionReturnName(param.getName());
 					}
 				}
 				else {
-					parameter = declaredParameters.get(parNameToCheck);
+					param = declaredParams.get(paramNameToCheck);
 				}
-				if (parameter != null) {
-					workParameters.add(parameter);
+				if (param != null) {
+					workParams.add(param);
 					if (logger.isDebugEnabled()) {
-						logger.debug("Using declared parameter for: " +
-								(parNameToUse == null ? getFunctionReturnName() : parNameToUse));
+						logger.debug("Using declared parameter for '" +
+								(paramNameToUse != null ? paramNameToUse : getFunctionReturnName()) + "'");
 					}
 				}
 			}
@@ -370,57 +376,57 @@ protected List<SqlParameter> reconcileParameters(List<SqlParameter> parameters)
 					if (!isFunction() && !isReturnValueRequired() &&
 							this.metaDataProvider.byPassReturnParameter(meta.getParameterName())) {
 						if (logger.isDebugEnabled()) {
-							logger.debug("Bypassing metadata return parameter for: " + meta.getParameterName());
+							logger.debug("Bypassing metadata return parameter for '" + meta.getParameterName() + "'");
 						}
 					}
 					else {
 						String returnNameToUse =(StringUtils.hasLength(meta.getParameterName()) ?
-								parNameToUse : getFunctionReturnName());
-						workParameters.add(this.metaDataProvider.createDefaultOutParameter(returnNameToUse, meta));
+								paramNameToUse : getFunctionReturnName());
+						workParams.add(this.metaDataProvider.createDefaultOutParameter(returnNameToUse, meta));
 						if (isFunction()) {
 							setFunctionReturnName(returnNameToUse);
-							outParameterNames.add(returnNameToUse);
+							outParamNames.add(returnNameToUse);
 						}
 						if (logger.isDebugEnabled()) {
-							logger.debug("Added metadata return parameter for: " + returnNameToUse);
+							logger.debug("Added metadata return parameter for '" + returnNameToUse + "'");
 						}
 					}
 				}
 				else {
 					if (meta.getParameterType() == DatabaseMetaData.procedureColumnOut) {
-						workParameters.add(this.metaDataProvider.createDefaultOutParameter(parNameToUse, meta));
-						outParameterNames.add(parNameToUse);
+						workParams.add(this.metaDataProvider.createDefaultOutParameter(paramNameToUse, meta));
+						outParamNames.add(paramNameToUse);
 						if (logger.isDebugEnabled()) {
-							logger.debug("Added metadata out parameter for: " + parNameToUse);
+							logger.debug("Added metadata out parameter for '" + paramNameToUse + "'");
 						}
 					}
 					else if (meta.getParameterType() == DatabaseMetaData.procedureColumnInOut) {
-						workParameters.add(this.metaDataProvider.createDefaultInOutParameter(parNameToUse, meta));
-						outParameterNames.add(parNameToUse);
+						workParams.add(this.metaDataProvider.createDefaultInOutParameter(paramNameToUse, meta));
+						outParamNames.add(paramNameToUse);
 						if (logger.isDebugEnabled()) {
-							logger.debug("Added metadata in out parameter for: " + parNameToUse);
+							logger.debug("Added metadata in out parameter for '" + paramNameToUse + "'");
 						}
 					}
 					else {
 						if (this.limitedInParameterNames.isEmpty() ||
-								limitedInParamNamesMap.containsKey(parNameToUse.toLowerCase())) {
-							workParameters.add(this.metaDataProvider.createDefaultInParameter(parNameToUse, meta));
+								limitedInParamNamesMap.containsKey(paramNameToUse.toLowerCase())) {
+							workParams.add(this.metaDataProvider.createDefaultInParameter(paramNameToUse, meta));
 							if (logger.isDebugEnabled()) {
-								logger.debug("Added metadata in parameter for: " + parNameToUse);
+								logger.debug("Added metadata in parameter for '" + paramNameToUse + "'");
 							}
 						}
 						else {
 							if (logger.isDebugEnabled()) {
 								logger.debug("Limited set of parameters " + limitedInParamNamesMap.keySet() +
-										" skipped parameter for: " + parNameToUse);
+										" skipped parameter for '" + paramNameToUse + "'");
 							}
 						}
 					}
 				}
 			}
 		}
 
-		return workParameters;
+		return workParams;
 	}
 
 	/**

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2002-2014 the original author or authors.`
	`2`	`+ * Copyright 2002-2015 the original author or authors.`
`3`	`3`	`*`
`4`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`5`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -280,88 +280,94 @@ public void processParameters(List<SqlParameter> parameters) {`
`280`	`280`	`* Reconcile the provided parameters with available metadata and add new ones where appropriate.`
`281`	`281`	`*/`
`282`	`282`	`protected List<SqlParameter> reconcileParameters(List<SqlParameter> parameters) {`
`283`		`- final List<SqlParameter> declaredReturnParameters = new ArrayList<SqlParameter>();`
`284`		`- final Map<String, SqlParameter> declaredParameters = new LinkedHashMap<String, SqlParameter>();`
	`283`	`+ final List<SqlParameter> declaredReturnParams = new ArrayList<SqlParameter>();`
	`284`	`+ final Map<String, SqlParameter> declaredParams = new LinkedHashMap<String, SqlParameter>();`
`285`	`285`	`boolean returnDeclared = false;`
`286`		`- List<String> outParameterNames = new ArrayList<String>();`
`287`		`- List<String> metaDataParameterNames = new ArrayList<String>();`
	`286`	`+ List<String> outParamNames = new ArrayList<String>();`
	`287`	`+ List<String> metaDataParamNames = new ArrayList<String>();`
`288`	`288`
`289`	`289`	`// Get the names of the meta data parameters`
`290`	`290`	`for (CallParameterMetaData meta : this.metaDataProvider.getCallParameterMetaData()) {`
`291`	`291`	`if (meta.getParameterType() != DatabaseMetaData.procedureColumnReturn) {`
`292`		`- metaDataParameterNames.add(meta.getParameterName().toLowerCase());`
	`292`	`+ metaDataParamNames.add(meta.getParameterName().toLowerCase());`
`293`	`293`	`}`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`// Separate implicit return parameters from explicit parameters...`
`297`		`- for (SqlParameter parameter : parameters) {`
`298`		`- if (parameter.isResultsParameter()) {`
`299`		`- declaredReturnParameters.add(parameter);`
	`297`	`+ for (SqlParameter param : parameters) {`
	`298`	`+ if (param.isResultsParameter()) {`
	`299`	`+ declaredReturnParams.add(param);`
`300`	`300`	`}`
`301`	`301`	`else {`
`302`		`- String parameterNameToMatch = this.metaDataProvider.parameterNameToUse(parameter.getName()).toLowerCase();`
`303`		`- declaredParameters.put(parameterNameToMatch, parameter);`
`304`		`- if (parameter instanceof SqlOutParameter) {`
`305`		`- outParameterNames.add(parameter.getName());`
`306`		`- if (isFunction() && !metaDataParameterNames.contains(parameterNameToMatch)) {`
	`302`	`+ String paramName = param.getName();`
	`303`	`+ if (paramName == null) {`
	`304`	`+ throw new IllegalArgumentException("Anonymous parameters not supported for calls - " +`
	`305`	`+ "please specify a name for the parameter of SQL type " + param.getSqlType());`
	`306`	`+ }`
	`307`	`+ String paramNameToMatch = this.metaDataProvider.parameterNameToUse(paramName).toLowerCase();`
	`308`	`+ declaredParams.put(paramNameToMatch, param);`
	`309`	`+ if (param instanceof SqlOutParameter) {`
	`310`	`+ outParamNames.add(paramName);`
	`311`	`+ if (isFunction() && !metaDataParamNames.contains(paramNameToMatch)) {`
`307`	`312`	`if (!returnDeclared) {`
`308`	`313`	`if (logger.isDebugEnabled()) {`
`309`		`- logger.debug("Using declared out parameter '" + parameter.getName() + "' for function return value");`
	`314`	`+ logger.debug("Using declared out parameter '" + paramName +`
	`315`	`+ "' for function return value");`
`310`	`316`	`}`
`311`		`- setFunctionReturnName(parameter.getName());`
	`317`	`+ setFunctionReturnName(paramName);`
`312`	`318`	`returnDeclared = true;`
`313`	`319`	`}`
`314`	`320`	`}`
`315`	`321`	`}`
`316`	`322`	`}`
`317`	`323`	`}`
`318`		`- setOutParameterNames(outParameterNames);`
	`324`	`+ setOutParameterNames(outParamNames);`
`319`	`325`
`320`		`- List<SqlParameter> workParameters = new ArrayList<SqlParameter>();`
`321`		`- workParameters.addAll(declaredReturnParameters);`
	`326`	`+ List<SqlParameter> workParams = new ArrayList<SqlParameter>();`
	`327`	`+ workParams.addAll(declaredReturnParams);`
`322`	`328`
`323`	`329`	`if (!this.metaDataProvider.isProcedureColumnMetaDataUsed()) {`
`324`		`- workParameters.addAll(declaredParameters.values());`
`325`		`- return workParameters;`
	`330`	`+ workParams.addAll(declaredParams.values());`
	`331`	`+ return workParams;`
`326`	`332`	`}`
`327`	`333`
`328`	`334`	`Map<String, String> limitedInParamNamesMap = new HashMap<String, String>(this.limitedInParameterNames.size());`
`329`		`- for (String limitedParameterName : this.limitedInParameterNames) {`
	`335`	`+ for (String limitedParamName : this.limitedInParameterNames) {`
`330`	`336`	`limitedInParamNamesMap.put(`
`331`		`- this.metaDataProvider.parameterNameToUse(limitedParameterName).toLowerCase(), limitedParameterName);`
	`337`	`+ this.metaDataProvider.parameterNameToUse(limitedParamName).toLowerCase(), limitedParamName);`
`332`	`338`	`}`
`333`	`339`
`334`	`340`	`for (CallParameterMetaData meta : this.metaDataProvider.getCallParameterMetaData()) {`
`335`		`- String parNameToCheck = null;`
	`341`	`+ String paramNameToCheck = null;`
`336`	`342`	`if (meta.getParameterName() != null) {`
`337`		`- parNameToCheck = this.metaDataProvider.parameterNameToUse(meta.getParameterName()).toLowerCase();`
	`343`	`+ paramNameToCheck = this.metaDataProvider.parameterNameToUse(meta.getParameterName()).toLowerCase();`
`338`	`344`	`}`
`339`		`- String parNameToUse = this.metaDataProvider.parameterNameToUse(meta.getParameterName());`
`340`		`- if (declaredParameters.containsKey(parNameToCheck) \|\|`
	`345`	`+ String paramNameToUse = this.metaDataProvider.parameterNameToUse(meta.getParameterName());`
	`346`	`+ if (declaredParams.containsKey(paramNameToCheck) \|\|`
`341`	`347`	`(meta.getParameterType() == DatabaseMetaData.procedureColumnReturn && returnDeclared)) {`
`342`		`- SqlParameter parameter;`
	`348`	`+ SqlParameter param;`
`343`	`349`	`if (meta.getParameterType() == DatabaseMetaData.procedureColumnReturn) {`
`344`		`- parameter = declaredParameters.get(getFunctionReturnName());`
`345`		`- if (parameter == null && getOutParameterNames().size() > 0) {`
`346`		`- parameter = declaredParameters.get(getOutParameterNames().get(0).toLowerCase());`
	`350`	`+ param = declaredParams.get(getFunctionReturnName());`
	`351`	`+ if (param == null && getOutParameterNames().size() > 0) {`
	`352`	`+ param = declaredParams.get(getOutParameterNames().get(0).toLowerCase());`
`347`	`353`	`}`
`348`		`- if (parameter == null) {`
	`354`	`+ if (param == null) {`
`349`	`355`	`throw new InvalidDataAccessApiUsageException(`
`350`	`356`	`"Unable to locate declared parameter for function return value - " +`
`351`		`- " add a SqlOutParameter with name \"" + getFunctionReturnName() +"\"");`
	`357`	`+ " add a SqlOutParameter with name '" + getFunctionReturnName() + "'");`
`352`	`358`	`}`
`353`	`359`	`else {`
`354`		`- setFunctionReturnName(parameter.getName());`
	`360`	`+ setFunctionReturnName(param.getName());`
`355`	`361`	`}`
`356`	`362`	`}`
`357`	`363`	`else {`
`358`		`- parameter = declaredParameters.get(parNameToCheck);`
	`364`	`+ param = declaredParams.get(paramNameToCheck);`
`359`	`365`	`}`
`360`		`- if (parameter != null) {`
`361`		`- workParameters.add(parameter);`
	`366`	`+ if (param != null) {`
	`367`	`+ workParams.add(param);`
`362`	`368`	`if (logger.isDebugEnabled()) {`
`363`		`- logger.debug("Using declared parameter for: " +`
`364`		`- (parNameToUse == null ? getFunctionReturnName() : parNameToUse));`
	`369`	`+ logger.debug("Using declared parameter for '" +`
	`370`	`+ (paramNameToUse != null ? paramNameToUse : getFunctionReturnName()) + "'");`
`365`	`371`	`}`
`366`	`372`	`}`
`367`	`373`	`}`
`@@ -370,57 +376,57 @@ protected List<SqlParameter> reconcileParameters(List<SqlParameter> parameters)`
`370`	`376`	`if (!isFunction() && !isReturnValueRequired() &&`
`371`	`377`	`this.metaDataProvider.byPassReturnParameter(meta.getParameterName())) {`
`372`	`378`	`if (logger.isDebugEnabled()) {`
`373`		`- logger.debug("Bypassing metadata return parameter for: " + meta.getParameterName());`
	`379`	`+ logger.debug("Bypassing metadata return parameter for '" + meta.getParameterName() + "'");`
`374`	`380`	`}`
`375`	`381`	`}`
`376`	`382`	`else {`
`377`	`383`	`String returnNameToUse =(StringUtils.hasLength(meta.getParameterName()) ?`
`378`		`- parNameToUse : getFunctionReturnName());`
`379`		`- workParameters.add(this.metaDataProvider.createDefaultOutParameter(returnNameToUse, meta));`
	`384`	`+ paramNameToUse : getFunctionReturnName());`
	`385`	`+ workParams.add(this.metaDataProvider.createDefaultOutParameter(returnNameToUse, meta));`
`380`	`386`	`if (isFunction()) {`
`381`	`387`	`setFunctionReturnName(returnNameToUse);`
`382`		`- outParameterNames.add(returnNameToUse);`
	`388`	`+ outParamNames.add(returnNameToUse);`
`383`	`389`	`}`
`384`	`390`	`if (logger.isDebugEnabled()) {`
`385`		`- logger.debug("Added metadata return parameter for: " + returnNameToUse);`
	`391`	`+ logger.debug("Added metadata return parameter for '" + returnNameToUse + "'");`
`386`	`392`	`}`
`387`	`393`	`}`
`388`	`394`	`}`
`389`	`395`	`else {`
`390`	`396`	`if (meta.getParameterType() == DatabaseMetaData.procedureColumnOut) {`
`391`		`- workParameters.add(this.metaDataProvider.createDefaultOutParameter(parNameToUse, meta));`
`392`		`- outParameterNames.add(parNameToUse);`
	`397`	`+ workParams.add(this.metaDataProvider.createDefaultOutParameter(paramNameToUse, meta));`
	`398`	`+ outParamNames.add(paramNameToUse);`
`393`	`399`	`if (logger.isDebugEnabled()) {`
`394`		`- logger.debug("Added metadata out parameter for: " + parNameToUse);`
	`400`	`+ logger.debug("Added metadata out parameter for '" + paramNameToUse + "'");`
`395`	`401`	`}`
`396`	`402`	`}`
`397`	`403`	`else if (meta.getParameterType() == DatabaseMetaData.procedureColumnInOut) {`
`398`		`- workParameters.add(this.metaDataProvider.createDefaultInOutParameter(parNameToUse, meta));`
`399`		`- outParameterNames.add(parNameToUse);`
	`404`	`+ workParams.add(this.metaDataProvider.createDefaultInOutParameter(paramNameToUse, meta));`
	`405`	`+ outParamNames.add(paramNameToUse);`
`400`	`406`	`if (logger.isDebugEnabled()) {`
`401`		`- logger.debug("Added metadata in out parameter for: " + parNameToUse);`
	`407`	`+ logger.debug("Added metadata in out parameter for '" + paramNameToUse + "'");`
`402`	`408`	`}`
`403`	`409`	`}`
`404`	`410`	`else {`
`405`	`411`	`if (this.limitedInParameterNames.isEmpty() \|\|`
`406`		`- limitedInParamNamesMap.containsKey(parNameToUse.toLowerCase())) {`
`407`		`- workParameters.add(this.metaDataProvider.createDefaultInParameter(parNameToUse, meta));`
	`412`	`+ limitedInParamNamesMap.containsKey(paramNameToUse.toLowerCase())) {`
	`413`	`+ workParams.add(this.metaDataProvider.createDefaultInParameter(paramNameToUse, meta));`
`408`	`414`	`if (logger.isDebugEnabled()) {`
`409`		`- logger.debug("Added metadata in parameter for: " + parNameToUse);`
	`415`	`+ logger.debug("Added metadata in parameter for '" + paramNameToUse + "'");`
`410`	`416`	`}`
`411`	`417`	`}`
`412`	`418`	`else {`
`413`	`419`	`if (logger.isDebugEnabled()) {`
`414`	`420`	`logger.debug("Limited set of parameters " + limitedInParamNamesMap.keySet() +`
`415`		`- " skipped parameter for: " + parNameToUse);`
	`421`	`+ " skipped parameter for '" + paramNameToUse + "'");`
`416`	`422`	`}`
`417`	`423`	`}`
`418`	`424`	`}`
`419`	`425`	`}`
`420`	`426`	`}`
`421`	`427`	`}`
`422`	`428`
`423`		`- return workParameters;`
	`429`	`+ return workParams;`
`424`	`430`	`}`
`425`	`431`
`426`	`432`	`/**`