Change how a Like comparator parameter is handled in a StringQuery. Replacing the provided parameter in a StringQuery with a new name or index when the named or indexed parameter is used more then once in the query.

Closes spring-projects#1929

Author: klajdipaja

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/QueryParameterSetterFactory.java

@@ -42,6 +42,7 @@
  * @author Jens Schauder
  * @author Oliver Gierke
  * @author Mark Paluch
+ * @author Klajdi Paja
  * @since 2.0
  */
 abstract class QueryParameterSetterFactory {
@@ -329,7 +330,7 @@ static jakarta.persistence.Parameter<?> of(@Nullable JpaParameter parameter, Par
 
 			Class<?> type = parameter == null ? Object.class : parameter.getType();
 
-			return new ParameterImpl<>(type, getName(parameter, binding), binding.getPosition());
+			return new ParameterImpl<>(type, getName(parameter, binding), getPosition(binding));
 		}
 
 		/**
@@ -370,9 +371,22 @@ private static String getName(@Nullable JpaParameter parameter, ParameterBinding
 				return binding.getName();
 			}
 
+			if (parameter.isNamedParameter() && StringQuery.LikeParameterBinding.class.equals(binding.getClass())) {
+				return ((StringQuery.LikeParameterBinding) binding).getUpdatedName();
+			}
+
 			return parameter.isNamedParameter() //
 					? parameter.getName().orElseThrow(() -> new IllegalArgumentException("o_O parameter needs to have a name")) //
 					: null;
 		}
+
+		@Nullable
+		private static Integer getPosition(ParameterBinding binding) {
+			if (StringQuery.LikeParameterBinding.class.equals(binding.getClass()) ) {
+				return ((StringQuery.LikeParameterBinding) binding).getUpdatedPosition();
+			}
+			return binding.getPosition();
+
+		}
 	}
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/StringQuery.java

@@ -20,10 +20,7 @@
 import static org.springframework.util.ObjectUtils.nullSafeHashCode;
 
 import java.lang.reflect.Array;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
 import java.util.function.BiFunction;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -51,9 +48,11 @@
  * @author Diego Krupitza
  * @author Greg Turnquist
  * @author Yuriy Tsarkov
+ * @author Klajdi Paja
  */
 class StringQuery implements DeclaredQuery {
 
+	public static final String LIKE_BINDING_RENAMING_PREFIX = "_like_binding_prefix";
 	private final String query;
 	private final List<ParameterBinding> bindings;
 	private final @Nullable String alias;
@@ -235,6 +234,8 @@ private String parseParameterBindingsOfQueryIntoBindingsAndReturnCleanedQuery(St
 			int expressionParameterIndex = parametersShouldBeAccessedByIndex ? greatestParameterIndex : 0;
 
 			boolean usesJpaStyleParameters = false;
+			HashMap<Object,Integer> occurrencesMap=buildOccurrencesMap(matcher,resultingQuery);
+
 			while (matcher.find()) {
 
 				if (spelExtractor.isQuoted(matcher.start())) {
@@ -269,14 +270,23 @@ private String parseParameterBindingsOfQueryIntoBindingsAndReturnCleanedQuery(St
 					case LIKE:
 
 						Type likeType = LikeParameterBinding.getLikeTypeFrom(matcher.group(2));
-						replacement = matcher.group(3);
+
+						// Convert the query defined by the user by replacing repeated parameters
+						// in a Like compare operator with a dynamic unique name.
+						// example: Select u from user u where u.name=:q or name like %:q%
+						// should be converted to: Select u from user u where u.name=:q or name like :q_prefix
+						// This would make sure that the value passed to q parameter is set correctly by the JPA Provider
 
 						if (parameterIndex != null) {
-							checkAndRegister(new LikeParameterBinding(parameterIndex, likeType, expression), bindings);
+							int updatedPosition = generateNewPosition(bindings, resultingQuery, occurrencesMap, parameterIndex, likeType);
+							LikeParameterBinding binding = new LikeParameterBinding(parameterIndex, updatedPosition, likeType, expression);
+							checkAndRegister(binding, bindings);
+							replacement = "?" + updatedPosition;
 						} else {
-							checkAndRegister(new LikeParameterBinding(parameterName, likeType, expression), bindings);
+							String updatedName = generateUpdatedName(bindings, occurrencesMap, parameterName, likeType);
+							checkAndRegister(new LikeParameterBinding(parameterName, updatedName, likeType, expression), bindings);
 
-							replacement = ":" + parameterName;
+							replacement = ":" + updatedName;
 						}
 
 						break;
@@ -308,6 +318,64 @@ private String parseParameterBindingsOfQueryIntoBindingsAndReturnCleanedQuery(St
 			return resultingQuery;
 		}
 
+		private static String generateUpdatedName(List<ParameterBinding> bindings, HashMap<Object, Integer> occurrencesMap,
+				String parameterName, Type likeType) {
+			Integer occurrences = occurrencesMap.get(parameterName);
+			boolean parameterIsRepeated = occurrences != null && occurrences > 1;
+			String updatedName = parameterName;
+			if (parameterIsRepeated) {
+				Optional<LikeParameterBinding> existingLikeBinding = findLikeBindingByNameOrIndex(parameterName, null, likeType,
+						bindings);
+				updatedName = existingLikeBinding.map(LikeParameterBinding::getUpdatedName)
+						.orElseGet(() -> parameterName + LIKE_BINDING_RENAMING_PREFIX);
+			}
+			return updatedName;
+		}
+
+		private static int generateNewPosition(List<ParameterBinding> bindings, String resultingQuery,
+				HashMap<Object, Integer> occurrencesMap, Integer parameterIndex, Type likeType) {
+			int updatedPosition;
+			Integer count = occurrencesMap.get(parameterIndex);
+			if (count != null && count > 1) {
+				int maxCurrentIndex = tryFindGreatestParameterIndexIn(resultingQuery);
+				updatedPosition = maxCurrentIndex + 1;
+			} else
+				updatedPosition = parameterIndex;
+
+			Optional<LikeParameterBinding> existingLikeBinding = findLikeBindingByNameOrIndex(null, parameterIndex, likeType,
+					bindings);
+			if (existingLikeBinding.isPresent()) {
+				updatedPosition = existingLikeBinding.get().getUpdatedPosition();
+			}
+			return updatedPosition;
+		}
+
+		private HashMap<Object, Integer> buildOccurrencesMap(Matcher m, String resultingQuery) {
+			Matcher matcher = PARAMETER_BINDING_PATTERN.matcher(resultingQuery);
+			HashMap<Object, Integer> map = new HashMap<>();
+			while (matcher.find()) {
+				String parameterIndexString = matcher.group(INDEXED_PARAMETER_GROUP);
+				boolean indexBasedAccess=parameterIndexString != null;
+				String parameterName = indexBasedAccess ? null : matcher.group(NAMED_PARAMETER_GROUP);
+				Integer parameterIndex = getParameterIndex(parameterIndexString);
+				Object param=indexBasedAccess ?parameterIndex:parameterName;
+				map.compute(param, (key, value) -> value == null ? 1 : value+1);
+			}
+			return map;
+		}
+
+		private static Optional<LikeParameterBinding> findLikeBindingByNameOrIndex(@Nullable String name,@Nullable Integer index,
+				Type type, List<ParameterBinding> bindings) {
+
+			return bindings.stream()//
+					.filter(it -> it instanceof LikeParameterBinding)//
+					.map(it -> (LikeParameterBinding) it)//
+					.filter(it -> it.getType().equals(type))//
+					.filter(it->name==null||name.equals(it.getRequiredName()))//
+					.filter(it->index==null || index.equals(it.getPosition()))//
+					.findFirst();
+		}
+
 		private static SpelExtractor createSpelExtractor(String queryWithSpel, boolean parametersShouldBeAccessedByIndex,
 				int greatestParameterIndex) {
 
@@ -637,6 +705,8 @@ static class LikeParameterBinding extends ParameterBinding {
 				Type.ENDING_WITH, Type.LIKE);
 
 		private final Type type;
+		private String updatedName;
+		private Integer updatedPosition;
 
 		/**
 		 * Creates a new {@link LikeParameterBinding} for the parameter with the given name and {@link Type}.
@@ -669,6 +739,23 @@ static class LikeParameterBinding extends ParameterBinding {
 			this.type = type;
 		}
 
+ /**
+		 * Creates a new {@link LikeParameterBinding} for the parameter with the given name and {@link Type} and parameter
+		 * binding input.
+		 *
+		 * @param name must not be {@literal null} or empty.
+		 * @param updatedName   the updated name of the parameter in the query. A new name should be created for the Like parameter
+		 *                          if a parameter shows up more than once in a query, it can be used later to set the value properly.
+		 * @param type must not be {@literal null}.
+		 * @param expression may be {@literal null}.
+		 */
+		LikeParameterBinding(String name, String updatedName, Type type, @Nullable String expression) {
+			this(name, type, expression);
+			Assert.hasText(updatedName, "Updated Name must not be null or empty");
+			this.updatedName = updatedName;
+
+		}
+
 		/**
 		 * Creates a new {@link LikeParameterBinding} for the parameter with the given position and {@link Type}.
 		 *
@@ -699,6 +786,23 @@ static class LikeParameterBinding extends ParameterBinding {
 			this.type = type;
 		}
 
+		/**
+		 * Creates a new {@link LikeParameterBinding} for the parameter with the given position, the updated position  and {@link Type}.
+		 *
+		 * @param position   position of the parameter in the query.
+		 * @param updatedPosition   the updated position of the parameter in the query. A new position should be created for the Like parameter
+		 *                          if a parameter shows up more than once in a query that can be used later to set the value properly.
+		 * @param type       must not be {@literal null}.
+		 * @param expression may be {@literal null}.
+		 */
+		LikeParameterBinding(int position, int updatedPosition, Type type, @Nullable String expression) {
+			this(position, type, expression);
+
+			Assert.isTrue(updatedPosition > 0, "UpdatedPosition must be greater than zero");
+			this.updatedPosition = updatedPosition;
+
+		}
+
 		/**
 		 * Returns the {@link Type} of the binding.
 		 *
@@ -708,6 +812,32 @@ public Type getType() {
 			return type;
 		}
 
+		/**
+		 * Returns the Updated Position of the binding in the query.
+		 *
+		 * @return the updated position
+		 */
+		public Integer getUpdatedPosition() {
+			return updatedPosition;
+		}
+
+		/**
+		 * Returns the Updated Name of the binding in the query.
+		 *
+		 * @return the updated name
+		 */
+		public String getUpdatedName() {
+			return updatedName;
+		}
+
+		/**
+		 * Check if the bindings updated name is equal to the provided name.
+		 *
+		 */
+		boolean hasUpdatedName(@Nullable String name) {
+			return this.updatedPosition == null && this.updatedName != null && this.updatedName.equals(name);
+		}
+
 		/**
 		 * Prepares the given raw keyword according to the like type.
 		 */
@@ -742,7 +872,8 @@ public boolean equals(Object obj) {
 
 			LikeParameterBinding that = (LikeParameterBinding) obj;
 
-			return super.equals(obj) && this.type.equals(that.type);
+			return super.equals(obj) && this.type.equals(that.type) && Objects.equals(this.updatedName,
+					that.updatedName) && Objects.equals(this.updatedPosition, that.updatedPosition);
 		}
 
 		@Override
@@ -751,13 +882,16 @@ public int hashCode() {
 			int result = super.hashCode();
 
 			result += nullSafeHashCode(this.type);
+			result += nullSafeHashCode(this.updatedName);
+			result += nullSafeHashCode(this.updatedPosition);
 
 			return result;
 		}
 
 		@Override
 		public String toString() {
-			return String.format("LikeBinding [name: %s, position: %d, type: %s]", getName(), getPosition(), type);
+			return String.format("LikeBinding [name: %s, position: %d, type: %s, updatedName: %s, updatedPosition: %d]",
+					getName(), getPosition(), type, updatedPosition, updatedPosition);
 		}
 
 		/**

spring-data-jpa/src/test/java/org/springframework/data/jpa/domain/sample/EmployeeWithMultipleFields.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2008-2023 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jpa.domain.sample;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author Klajdi Paja
+ */
+@Entity
+@Data
+@NoArgsConstructor
+public class EmployeeWithMultipleFields {
+
+	@Id
+	@GeneratedValue
+	private Integer id;
+	private String name;
+	private String lastName;
+	private String username;
+
+	public EmployeeWithMultipleFields(String name, String lastName, String username) {
+		this.name = name;
+		this.lastName = lastName;
+		this.username = username;
+	}
+}