Polishing.

See #2409.

Author: gregturn

Diff for: pom.xml

@@ -23,11 +23,11 @@
 
 		<eclipselink>2.7.9</eclipselink>
 		<hibernate>5.6.0.Final</hibernate>
+		<jsqlparser>4.3</jsqlparser>
 		<mysql-connector-java>8.0.23</mysql-connector-java>
 		<postgresql>42.2.19</postgresql>
 		<springdata.commons>2.7.0-SNAPSHOT</springdata.commons>
 		<vavr>0.10.3</vavr>
-		<jsqlparser.version>4.3</jsqlparser.version>
 
 		<hibernate.groupId>org.hibernate</hibernate.groupId>
 
@@ -376,7 +376,7 @@
 		<dependency>
 			<groupId>com.github.jsqlparser</groupId>
 			<artifactId>jsqlparser</artifactId>
-			<version>${jsqlparser.version}</version>
+			<version>${jsqlparser}</version>
 			<scope>provided</scope>
 			<optional>true</optional>
 		</dependency>

Diff for: src/main/java/org/springframework/data/jpa/repository/query/AbstractJpaQuery.java

@@ -69,7 +69,7 @@ public abstract class AbstractJpaQuery implements RepositoryQuery {
 	private final PersistenceProvider provider;
 	private final Lazy<JpaQueryExecution> execution;
 
-	final Lazy<ParameterBinder> parameterBinder = new Lazy<>(this::createBinder);
+	final Lazy<ParameterBinder> parameterBinder = Lazy.of(this::createBinder);
 
 	/**
 	 * Creates a new {@link AbstractJpaQuery} from the given {@link JpaQueryMethod}.

Diff for: src/main/java/org/springframework/data/jpa/repository/query/DefaultQueryEnhancer.java

@@ -15,14 +15,16 @@
  */
 package org.springframework.data.jpa.repository.query;
 
-import org.springframework.data.domain.Sort;
-
 import java.util.Set;
 
+import org.springframework.data.domain.Sort;
+import org.springframework.lang.Nullable;
+
 /**
  * The implementation of {@link QueryEnhancer} using {@link QueryUtils}.
  *
  * @author Diego Krupitza
+ * @since 2.7.0
  */
 public class DefaultQueryEnhancer implements QueryEnhancer {
 
@@ -33,17 +35,7 @@ public DefaultQueryEnhancer(DeclaredQuery query) {
 	}
 
 	@Override
-	public String getExistsQueryString(String entityName, String countQueryPlaceHolder, Iterable<String> idAttributes) {
-		return QueryUtils.getExistsQueryString(entityName, countQueryPlaceHolder, idAttributes);
-	}
-
-	@Override
-	public String getQueryString(String template, String entityName) {
-		return QueryUtils.getQueryString(template, entityName);
-	}
-
-	@Override
-	public String applySorting(Sort sort, String alias) {
+	public String applySorting(Sort sort, @Nullable String alias) {
 		return QueryUtils.applySorting(this.query.getQueryString(), sort, alias);
 	}
 
@@ -53,7 +45,7 @@ public String detectAlias() {
 	}
 
 	@Override
-	public String createCountQueryFor(String countProjection) {
+	public String createCountQueryFor(@Nullable String countProjection) {
 		return QueryUtils.createCountQueryFor(this.query.getQueryString(), countProjection);
 	}
 

Diff for: src/main/java/org/springframework/data/jpa/repository/query/ExpressionBasedStringQuery.java

@@ -69,19 +69,18 @@ public ExpressionBasedStringQuery(String query, JpaEntityMetadata<?> metadata, S
 	 * @param query the original query. Must not be {@literal null}.
 	 * @param metadata the {@link JpaEntityMetadata} for the given entity. Must not be {@literal null}.
 	 * @param parser Parser for resolving SpEL expressions. Must not be {@literal null}.
-	 * @param nativeQuery
+	 * @param nativeQuery is a given query native or not
 	 * @return A query supporting SpEL expressions.
 	 */
-	static ExpressionBasedStringQuery from(DeclaredQuery query, JpaEntityMetadata metadata, SpelExpressionParser parser,
-			boolean nativeQuery) {
+	static ExpressionBasedStringQuery from(DeclaredQuery query, JpaEntityMetadata<?> metadata,
+			SpelExpressionParser parser, boolean nativeQuery) {
 		return new ExpressionBasedStringQuery(query.getQueryString(), metadata, parser, nativeQuery);
 	}
 
 	/**
-	 * @param query, the query expression potentially containing a SpEL expression. Must not be {@literal null}.}
+	 * @param query, the query expression potentially containing a SpEL expression. Must not be {@literal null}.
 	 * @param metadata the {@link JpaEntityMetadata} for the given entity. Must not be {@literal null}.
 	 * @param parser Must not be {@literal null}.
-	 * @return
 	 */
 	private static String renderQueryIfExpressionOrReturnQuery(String query, JpaEntityMetadata<?> metadata,
 			SpelExpressionParser parser) {

Diff for: src/main/java/org/springframework/data/jpa/repository/query/JSqlParserQueryEnhancer.java

@@ -15,38 +15,44 @@
  */
 package org.springframework.data.jpa.repository.query;
 
+import static org.springframework.data.jpa.repository.query.JSqlParserUtils.*;
+import static org.springframework.data.jpa.repository.query.QueryUtils.*;
+
 import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.expression.Alias;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.Function;
-import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
-import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.schema.Table;
-import net.sf.jsqlparser.statement.select.*;
-import net.sf.jsqlparser.util.SelectUtils;
+import net.sf.jsqlparser.statement.select.OrderByElement;
+import net.sf.jsqlparser.statement.select.PlainSelect;
+import net.sf.jsqlparser.statement.select.Select;
+import net.sf.jsqlparser.statement.select.SelectExpressionItem;
+import net.sf.jsqlparser.statement.select.SelectItem;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
 import org.springframework.data.domain.Sort;
-import org.springframework.data.util.Streamable;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.StringUtils;
 
-import java.util.*;
-import java.util.stream.Collectors;
-
-import static org.springframework.data.jpa.repository.query.JSqlParserUtils.*;
-import static org.springframework.data.jpa.repository.query.QueryUtils.checkSortExpression;
-
 /**
  * The implementation of {@link QueryEnhancer} using JSqlParser.
  *
  * @author Diego Krupitza
+ * @author Greg Turnquist
+ * @since 2.7.0
  */
 public class JSqlParserQueryEnhancer implements QueryEnhancer {
 
-	private static final String DEFAULT_TABLE_ALIAS = "x";
-
 	private final DeclaredQuery query;
 
 	/**
@@ -57,40 +63,8 @@ public JSqlParserQueryEnhancer(DeclaredQuery query) {
 	}
 
 	@Override
-	public String getExistsQueryString(String entityName, String countQueryPlaceHolder, Iterable<String> idAttributes) {
-		final Table tableNameWithAlias = getTableWithAlias(entityName, DEFAULT_TABLE_ALIAS);
-		Function jSqlCount = getJSqlCount(Collections.singletonList(countQueryPlaceHolder), false);
-
-		Select select = SelectUtils.buildSelectFromTableAndSelectItems(tableNameWithAlias,
-				new SelectExpressionItem(jSqlCount));
-
-		PlainSelect selectBody = (PlainSelect) select.getSelectBody();
-
-		List<Expression> equalityExpressions = Streamable.of(idAttributes).stream() //
-				.map(field -> {
-					Expression tableNameField = new Column().withTable(tableNameWithAlias).withColumnName(field);
-					Expression inputField = new Column(":".concat(field));
-					return new EqualsTo(tableNameField, inputField);
-				}).collect(Collectors.toList());
-
-		if (equalityExpressions.size() > 1) {
-			AndExpression rootOfWhereClause = concatenateWithAndExpression(equalityExpressions);
-			selectBody.setWhere(rootOfWhereClause);
-		} else if (equalityExpressions.size() == 1) {
-			selectBody.setWhere(equalityExpressions.get(0));
-		}
+	public String applySorting(Sort sort, @Nullable String alias) {
 
-		return selectBody.toString();
-	}
-
-	@Override
-	public String getQueryString(String template, String entityName) {
-		Assert.hasText(entityName, "Entity name must not be null or empty!");
-		return String.format(template, entityName);
-	}
-
-	@Override
-	public String applySorting(Sort sort, String alias) {
 		String queryString = query.getQueryString();
 		Assert.hasText(queryString, "Query must not be null or empty!");
 
@@ -145,6 +119,7 @@ private Set<String> getSelectionAliases(PlainSelect selectBody) {
 	 * @return a {@literal Set} containing all found aliases. Guaranteed to be not {@literal null}.
 	 */
 	Set<String> getSelectionAliases() {
+
 		Select selectStatement = parseSelectStatement(this.query.getQueryString());
 		PlainSelect selectBody = (PlainSelect) selectStatement.getSelectBody();
 		return this.getSelectionAliases(selectBody);
@@ -189,7 +164,7 @@ private Set<String> getJoinAliases(PlainSelect selectBody) {
 	 * @return a {@link OrderByElement} containing an order clause. Guaranteed to be not {@literal null}.
 	 */
 	private OrderByElement getOrderClause(final Set<String> joinAliases, final Set<String> selectionAliases,
-			final String alias, final Sort.Order order) {
+			@Nullable final String alias, final Sort.Order order) {
 
 		final OrderByElement orderByElement = new OrderByElement();
 		orderByElement.setAsc(order.getDirection().isAscending());
@@ -233,7 +208,9 @@ public String detectAlias() {
 	 * @param query must not be {@literal null}.
 	 * @return Might return {@literal null}.
 	 */
+	@Nullable
 	private String detectAlias(String query) {
+
 		Select selectStatement = parseSelectStatement(query);
 		PlainSelect selectBody = (PlainSelect) selectStatement.getSelectBody();
 		return detectAlias(selectBody);
@@ -246,13 +223,15 @@ private String detectAlias(String query) {
 	 * @param selectBody must not be {@literal null}.
 	 * @return Might return {@literal null}.
 	 */
+	@Nullable
 	private static String detectAlias(PlainSelect selectBody) {
+
 		Alias alias = selectBody.getFromItem().getAlias();
 		return alias == null ? null : alias.getName();
 	}
 
 	@Override
-	public String createCountQueryFor(String countProjection) {
+	public String createCountQueryFor(@Nullable String countProjection) {
 
 		Assert.hasText(this.query.getQueryString(), "OriginalQuery must not be null or empty!");
 
@@ -298,6 +277,7 @@ public String createCountQueryFor(String countProjection) {
 
 	@Override
 	public String getProjection() {
+
 		Assert.hasText(query.getQueryString(), "Query must not be null or empty!");
 
 		Select selectStatement = parseSelectStatement(query.getQueryString());
@@ -321,6 +301,7 @@ public Set<String> getJoinAliases() {
 	 * @return the parsed query
 	 */
 	private static Select parseSelectStatement(String query) {
+
 		try {
 			return (Select) CCJSqlParserUtil.parse(query);
 		} catch (JSQLParserException e) {
@@ -329,12 +310,13 @@ private static Select parseSelectStatement(String query) {
 	}
 
 	/**
-	 * Checks whether a given projection only contains a single column definition (aka without functions, etc)
+	 * Checks whether a given projection only contains a single column definition (aka without functions, etc.)
 	 *
 	 * @param projection the projection to analyse
 	 * @return <code>true</code> when the projection only contains a single column definition otherwise <code>false</code>
 	 */
 	private boolean onlyASingleColumnProjection(List<SelectItem> projection) {
+
 		// this is unfortunately the only way to check without any hacky & hard string regex magic
 		return projection.size() == 1 && projection.get(0) instanceof SelectExpressionItem
 				&& (((SelectExpressionItem) projection.get(0)).getExpression()) instanceof Column;

Diff for: src/main/java/org/springframework/data/jpa/repository/query/JSqlParserUtils.java

@@ -15,15 +15,10 @@
  */
 package org.springframework.data.jpa.repository.query;
 
-import net.sf.jsqlparser.expression.Alias;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.Function;
-import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
 import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.schema.Table;
-import org.springframework.util.CollectionUtils;
-import org.springframework.util.StringUtils;
 
 import java.util.Collections;
 import java.util.List;
@@ -33,58 +28,12 @@
  * A utility class for JSqlParser.
  *
  * @author Diego Krupitza
+ * @author Greg Turnquist
+ * @since 2.7.0
  */
 public final class JSqlParserUtils {
 
-	private JSqlParserUtils() {
-	}
-
-	/**
-	 * Generates a JSqlParser table from an entity name and an optional alias name
-	 *
-	 * @param entityName the name of the table
-	 * @param alias the optional alias. Might be {@literal null} or empty
-	 * @return the newly generated table
-	 */
-	public static Table getTableWithAlias(String entityName, String alias) {
-		Table table = new Table(entityName);
-		return StringUtils.hasText(alias) ? table.withAlias(new Alias(alias)) : table;
-	}
-
-	/**
-	 * Concatenates a list of expression with <code>AND</code>.
-	 *
-	 * @param expressions the list of expressions to concatenate. Has to be non empty and with size >= 2
-	 * @return the root of the concatenated expression
-	 */
-	public static AndExpression concatenateWithAndExpression(List<Expression> expressions) {
-
-		if (CollectionUtils.isEmpty(expressions) || expressions.size() == 1) {
-			throw new IllegalArgumentException(
-					"The list of expression has to be at least of length 2! Otherwise it is not possible to concatinate with an");
-		}
-
-		AndExpression rootAndExpression = new AndExpression();
-		AndExpression currentLocation = rootAndExpression;
-
-		// traverse the list with looking 1 element ahead
-		for (int i = 0; i < expressions.size(); i++) {
-			Expression currentExpression = expressions.get(i);
-			if (currentLocation.getLeftExpression() == null) {
-				currentLocation.setLeftExpression(currentExpression);
-			} else if (currentLocation.getRightExpression() == null && i == expressions.size() - 1) {
-				currentLocation.setRightExpression(currentExpression);
-			} else {
-				AndExpression nextAndExpression = new AndExpression();
-				nextAndExpression.setLeftExpression(currentExpression);
-
-				currentLocation.setRightExpression(nextAndExpression);
-				currentLocation = (AndExpression) currentLocation.getRightExpression();
-			}
-		}
-
-		return rootAndExpression;
-	}
+	private JSqlParserUtils() {}
 
 	/**
 	 * Generates a count function call, based on the {@code countFields}.
@@ -94,12 +43,14 @@ public static AndExpression concatenateWithAndExpression(List<Expression> expres
 	 * @return the generated count function call
 	 */
 	public static Function getJSqlCount(final List<String> countFields, final boolean distinct) {
+
 		List<Expression> countColumns = countFields //
 				.stream() //
 				.map(Column::new) //
 				.collect(Collectors.toList());
 
 		ExpressionList countExpression = new ExpressionList(countColumns);
+
 		return new Function() //
 				.withName("count") //
 				.withParameters(countExpression) //
@@ -113,11 +64,12 @@ public static Function getJSqlCount(final List<String> countFields, final boolea
 	 * @return the generated lower function call
 	 */
 	public static Function getJSqlLower(String column) {
+
 		List<Expression> expressions = Collections.singletonList(new Column(column));
 		ExpressionList lowerParamExpression = new ExpressionList(expressions);
+
 		return new Function() //
 				.withName("lower") //
 				.withParameters(lowerParamExpression);
 	}
-
 }