From 170d31707c02795ed439bc4367fd9099e8867304 Mon Sep 17 00:00:00 2001
From: Oliver Gierke <info@olivergierke.de>
Date: Sun, 4 Sep 2011 14:56:39 +0200
Subject: [PATCH] DATAJPA-96 - JpaQueryCreator now correctly resolves nested
 properties for all supported keywords.

Removed Part.toDotPath() references to create Expressions as they have to be atomic.
---
 .../data/jpa/repository/query/JpaQueryCreator.java  | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryCreator.java b/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryCreator.java
index 8553f128e..cec67c314 100644
--- a/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryCreator.java
+++ b/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryCreator.java
@@ -191,6 +191,11 @@ public class JpaQueryCreator extends AbstractQueryCreator<CriteriaQuery<Object>,
 	@SuppressWarnings({ "rawtypes" })
 	private Expression<? extends Comparable> getComparablePath(Root<?> root, Part part) {
 
+		return getTypedPath(root, part, Comparable.class);
+	}
+
+	private <T> Expression<? extends T> getTypedPath(Root<?> root, Part part, Class<T> type) {
+
 		return toExpressionRecursively(root, part.getProperty());
 	}
 
@@ -315,7 +320,7 @@ public class JpaQueryCreator extends AbstractQueryCreator<CriteriaQuery<Object>,
 			case BETWEEN:
 				ParameterExpression<Comparable> first = provider.next();
 				ParameterExpression<Comparable> second = provider.next();
-				return builder.between(root.<Comparable> get(part.getProperty().toDotPath()), first, second);
+				return builder.between(getComparablePath(root, part), first, second);
 			case GREATER_THAN:
 				return builder.greaterThan(getComparablePath(root, part), provider.next(Comparable.class));
 			case LESS_THAN:
@@ -330,7 +335,7 @@ public class JpaQueryCreator extends AbstractQueryCreator<CriteriaQuery<Object>,
 				return path.in(provider.next(Collection.class));
 			case LIKE:
 			case NOT_LIKE:
-				Expression<String> propertyExpression = upperIfIgnoreCase(root.<String> get(part.getProperty().toDotPath()));
+				Expression<String> propertyExpression = upperIfIgnoreCase(getTypedPath(root, part, String.class));
 				Expression<String> parameterExpression = upperIfIgnoreCase(provider.next(String.class));
 				Predicate like = builder.like(propertyExpression, parameterExpression);
 				return part.getType() == Type.LIKE ? like : like.not();
@@ -350,7 +355,7 @@ public class JpaQueryCreator extends AbstractQueryCreator<CriteriaQuery<Object>,
 		 * @param expression must not be {@literal null}.
 		 * @return
 		 */
-		private <T> Expression<T> upperIfIgnoreCase(Expression<T> expression) {
+		private <T> Expression<T> upperIfIgnoreCase(Expression<? extends T> expression) {
 
 			switch (part.shouldIgnoreCase()) {
 			case ALWAYS:
@@ -362,7 +367,7 @@ public class JpaQueryCreator extends AbstractQueryCreator<CriteriaQuery<Object>,
 					return (Expression<T>) builder.upper((Expression<String>) expression);
 				}
 			}
-			return expression;
+			return (Expression<T>) expression;
 		}
 
 		private boolean canUpperCase(Expression<?> expression) {