HHH-18990 refinements to Path, add NotNull range

gavinking · gavinking · commit f4a1563270c6 · 2024-12-28T23:11:09.000+01:00
diff --git a/documentation/src/main/asciidoc/introduction/Interacting.adoc b/documentation/src/main/asciidoc/introduction/Interacting.adoc
@@ -1091,8 +1091,7 @@ The interface link:{doc-javadoc-url}org/hibernate/query/Path.html[`Path`] may be
 ----
 List<Book> booksForPublisher =
         session.createSelectionQuery("from Book", Book.class)
-                .addRestriction(Path.root(Book_.publisher)
-                                .get(Publisher_.name)
+                .addRestriction(Path.from(Book.class).to(Book_.publisher).to(Publisher_.name)
                                 .equalTo(publisherName))
                 .getResultList();
 ----
diff --git a/hibernate-core/src/main/java/org/hibernate/query/NamedAttributeRange.java b/hibernate-core/src/main/java/org/hibernate/query/NamedAttributeRange.java
@@ -13,7 +13,8 @@
 import org.hibernate.query.range.Range;
 
 /**
- * Restricts an attribute of an entity to a given {@link Range}.
+ * Restricts an attribute of an entity to a given {@link Range},
+ * using a stringly-typed attribute reference.
  *
  * @param <X> The entity type
  * @param <U> The attribute type
@@ -36,9 +37,10 @@ public Predicate toPredicate(Root<? extends X> root, CriteriaBuilder builder) {
 		if ( !(attribute instanceof SingularAttribute) ) {
 			throw new IllegalArgumentException( "Attribute '" + attributeName + "' is not singular" );
 		}
-		if ( range.getType()!=null && !range.getType().isAssignableFrom( attribute.getJavaType() ) ) {
+		final Class<? extends U> rangeType = range.getType();
+		if ( rangeType != null && !rangeType.isAssignableFrom( attribute.getJavaType() ) ) {
 			throw new IllegalArgumentException( "Attribute '" + attributeName
-					+ "' is not assignable to range of type '" + range.getType().getName() + "'" );
+												+ "' is not assignable to range of type '" + rangeType.getName() + "'" );
 		}
 		return range.toPredicate( root.get( attributeName ), builder );
 	}
diff --git a/hibernate-core/src/main/java/org/hibernate/query/NamedPathElement.java b/hibernate-core/src/main/java/org/hibernate/query/NamedPathElement.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.query;
+
+import jakarta.persistence.criteria.Root;
+
+/**
+ * A non-root element of a {@link Path}, using a stringly-typed
+ * attribute reference.
+ *
+ * @author Gavin King
+ */
+record NamedPathElement<X, U, V>(Path<? super X, U> parent, String attributeName, Class<V> attributeType)
+		implements Path<X, V> {
+	@Override
+	public Class<V> getType() {
+		return attributeType;
+	}
+
+	@Override
+	public jakarta.persistence.criteria.Path<V> path(Root<? extends X> root) {
+		final jakarta.persistence.criteria.Path<V> path = parent.path( root ).get( attributeName );
+		if ( !attributeType.isAssignableFrom( path.getJavaType() ) ) {
+			throw new IllegalArgumentException( "Attribute '" + attributeName
+												+ "' is not of type '" + attributeType.getName() + "'" );
+		}
+		return path;
+	}
+}
diff --git a/hibernate-core/src/main/java/org/hibernate/query/Path.java b/hibernate-core/src/main/java/org/hibernate/query/Path.java
@@ -18,7 +18,8 @@
  * the root entity type of the query.
  * <pre>
  * session.createSelectionQuery("from Book", Book.class)
- *         .addRestriction(root(publisher).get(name).equalTo("Manning"))
+ *         .addRestriction(from(Book.class).to(Book_.publisher).to(Publisher_.name)
+ *                         .equalTo("Manning"))
  *         .getResultList()
  * </pre>
  * A compound path-based restriction has the same semantics as the
@@ -37,15 +38,21 @@
 public interface Path<X,U> {
 	jakarta.persistence.criteria.Path<U> path(Root<? extends X> root);
 
-	default <V> Path<X, V> get(SingularAttribute<? super U, V> attribute) {
+	Class<U> getType();
+
+	default <V> Path<X, V> to(SingularAttribute<? super U, V> attribute) {
 		return new PathElement<>( this, attribute );
 	}
 
-	static <X, U> Path<X, U> root(SingularAttribute<? super X, U> attribute) {
-		return new PathRoot<X>().get( attribute );
+	default <V> Path<X, V> to(String attributeName, Class<V> attributeType) {
+		return new NamedPathElement<>( this, attributeName, attributeType );
+	}
+
+	static <X> Path<X, X> from(Class<X> type) {
+		return new PathRoot<>( type );
 	}
 
-	default Restriction<X> restrict(Range<U> range) {
+	default Restriction<X> restrict(Range<? super U> range) {
 		return new PathRange<>( this, range );
 	}
 
@@ -65,5 +72,7 @@ default Restriction<X> notIn(List<U> values) {
 		return in( values ).negated();
 	}
 
-	//TODO: between, lessThan, greaterThan?
+	default Restriction<X> notNull() {
+		return restrict( Range.notNull( getType() ) );
+	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/query/PathElement.java b/hibernate-core/src/main/java/org/hibernate/query/PathElement.java
@@ -12,7 +12,13 @@
  *
  * @author Gavin King
  */
-record PathElement<X, U, V>(Path<? super X, U> parent, SingularAttribute<? super U, V> attribute) implements Path<X, V> {
+record PathElement<X, U, V>(Path<? super X, U> parent, SingularAttribute<? super U, V> attribute)
+		implements Path<X, V> {
+	@Override
+	public Class<V> getType() {
+		return attribute.getJavaType();
+	}
+
 	@Override
 	public jakarta.persistence.criteria.Path<V> path(Root<? extends X> root) {
 		return parent.path( root ).get( attribute );
diff --git a/hibernate-core/src/main/java/org/hibernate/query/PathRange.java b/hibernate-core/src/main/java/org/hibernate/query/PathRange.java
@@ -17,7 +17,7 @@
  *
  * @author Gavin King
  */
-record PathRange<X, U>(Path<X, U> path, Range<U> range) implements Restriction<X> {
+record PathRange<X, U>(Path<X, U> path, Range<? super U> range) implements Restriction<X> {
 	@Override
 	public Restriction<X> negated() {
 		return new Negation<>( this );
diff --git a/hibernate-core/src/main/java/org/hibernate/query/PathRoot.java b/hibernate-core/src/main/java/org/hibernate/query/PathRoot.java
@@ -11,7 +11,12 @@
  *
  * @author Gavin King
  */
-record PathRoot<X>() implements Path<X, X> {
+record PathRoot<X>(Class<X> type) implements Path<X, X> {
+	@Override
+	public Class<X> getType() {
+		return type;
+	}
+
 	@Override
 	@SuppressWarnings("unchecked")
 	public jakarta.persistence.criteria.Path<X> path(Root<? extends X> root) {
diff --git a/hibernate-core/src/main/java/org/hibernate/query/Restriction.java b/hibernate-core/src/main/java/org/hibernate/query/Restriction.java
@@ -203,6 +203,10 @@ static <T> Restriction<T> notContains(SingularAttribute<T, String> attribute, St
 		return contains( attribute, substring, caseSensitive ).negated();
 	}
 
+	static <T, U> Restriction<T> notNull(SingularAttribute<T, U> attribute) {
+		return restrict( attribute, Range.notNull( attribute.getJavaType() ) );
+	}
+
 	static <T> Restriction<T> all(List<? extends Restriction<? super T>> restrictions) {
 		return new Conjunction<>( restrictions );
 	}
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/CaseInsensitiveValue.java b/hibernate-core/src/main/java/org/hibernate/query/range/CaseInsensitiveValue.java
@@ -23,13 +23,15 @@ record CaseInsensitiveValue(String value) implements Range<String> {
 	}
 
 	@Override
-	public Predicate toPredicate(Path<String> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends String> path, CriteriaBuilder builder) {
 		// TODO: it would be much better to not do use literal,
 		//       and let it be treated as a parameter, but we
 		//       we run into the usual bug with parameters in
 		//       manipulated SQM trees
+		@SuppressWarnings("unchecked")
+		final Path<String> stringPath = (Path<String>) path; // safe, because String is final
 		final Expression<String> literal = builder.literal( value.toLowerCase( Locale.ROOT ) );
-		return builder.lower( path ).equalTo( literal );
+		return builder.lower( stringPath ).equalTo( literal );
 	}
 
 	@Override
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/EmptyRange.java b/hibernate-core/src/main/java/org/hibernate/query/range/EmptyRange.java
@@ -15,12 +15,12 @@
  */
 record EmptyRange<U>(Class<U> type) implements Range<U> {
 	@Override
-	public Class<? extends U> getType() {
+	public Class<U> getType() {
 		return type;
 	}
 
 	@Override
-	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
 		return builder.disjunction();
 	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/FullRange.java b/hibernate-core/src/main/java/org/hibernate/query/range/FullRange.java
@@ -15,12 +15,12 @@
  */
 record FullRange<U>(Class<U> type) implements Range<U> {
 	@Override
-	public Class<? extends U> getType() {
+	public Class<U> getType() {
 		return type;
 	}
 
 	@Override
-	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
 		return builder.conjunction();
 	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/Interval.java b/hibernate-core/src/main/java/org/hibernate/query/range/Interval.java
@@ -16,7 +16,7 @@
 record Interval<U extends Comparable<U>>(LowerBound<U> lowerBound, UpperBound<U> upperBound)
 		implements Range<U> {
 	@Override
-	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
 		return lowerBound.open() || upperBound.open()
 				? builder.and( lowerBound.toPredicate( path, builder ), upperBound.toPredicate( path, builder ) )
 				: builder.between( path, builder.literal( lowerBound.bound() ), builder.literal( upperBound.bound() ) );
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/LowerBound.java b/hibernate-core/src/main/java/org/hibernate/query/range/LowerBound.java
@@ -22,7 +22,7 @@ record LowerBound<U extends Comparable<U>>(U bound, boolean open) implements Ran
 	}
 
 	@Override
-	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
 		// TODO: it would be much better to not do use literal,
 		//       and let it be treated as a parameter, but we
 		//       we run into the usual bug with parameters in
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/NotNull.java b/hibernate-core/src/main/java/org/hibernate/query/range/NotNull.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.query.range;
+
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.Path;
+import jakarta.persistence.criteria.Predicate;
+
+/**
+ * A {@link Range} containing every value of the given type,
+ * except the null value.
+ *
+ * @author Gavin King
+ */
+record NotNull<U>(Class<U> type) implements Range<U> {
+	@Override
+	public Class<U> getType() {
+		return type;
+	}
+
+	@Override
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
+		return path.isNotNull();
+	}
+}
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/Pattern.java b/hibernate-core/src/main/java/org/hibernate/query/range/Pattern.java
@@ -21,10 +21,12 @@ record Pattern(String pattern, boolean caseSensitive) implements Range<String> {
 	}
 
 	@Override
-	public Predicate toPredicate(Path<String> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends String> path, CriteriaBuilder builder) {
+		@SuppressWarnings("unchecked")
+		final Path<String> stringPath = (Path<String>) path; // safe, because String is final
 		return caseSensitive
-				? builder.like( path, builder.literal( pattern ), '\\' )
-				: builder.like( builder.lower( path ),
+				? builder.like( stringPath, builder.literal( pattern ), '\\' )
+				: builder.like( builder.lower( stringPath ),
 						builder.literal( pattern.toLowerCase( Locale.ROOT ) ),
 						'\\' );
 	}
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/Range.java b/hibernate-core/src/main/java/org/hibernate/query/range/Range.java
@@ -39,7 +39,7 @@ public interface Range<U> {
 	 * values.
 	 */
 	@Internal
-	Predicate toPredicate(Path<U> path, CriteriaBuilder builder);
+	Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder);
 
 	static <U> Range<U> singleValue(U value) {
 		return new Value<>( value );
@@ -123,6 +123,10 @@ static <U> Range<U> full(Class<U> type) {
 		return new FullRange<>( type );
 	}
 
+	static <U> Range<U> notNull(Class<U> type) {
+		return new NotNull<>( type );
+	}
+
 	private static String escape(String literal) {
 		final var result = new StringBuilder();
 		for ( int i = 0; i < literal.length(); i++ ) {
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/UpperBound.java b/hibernate-core/src/main/java/org/hibernate/query/range/UpperBound.java
@@ -22,7 +22,7 @@ record UpperBound<U extends Comparable<U>>(U bound, boolean open) implements Ran
 	}
 
 	@Override
-	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
 		// TODO: it would be much better to not do use literal,
 		//       and let it be treated as a parameter, but we
 		//       we run into the usual bug with parameters in
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/Value.java b/hibernate-core/src/main/java/org/hibernate/query/range/Value.java
@@ -22,7 +22,7 @@ record Value<U>(U value) implements Range<U> {
 	}
 
 	@Override
-	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
 		// TODO: it would be much better to not do use literal,
 		//       and let it be treated as a parameter, but we
 		//       we run into the usual bug with parameters in
diff --git a/hibernate-core/src/main/java/org/hibernate/query/range/ValueList.java b/hibernate-core/src/main/java/org/hibernate/query/range/ValueList.java
@@ -25,7 +25,7 @@ record ValueList<U>(List<U> values) implements Range<U> {
 	}
 
 	@Override
-	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+	public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {
 		return path.in( values.stream().map( builder::literal ).toList() );
 	}
 
diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/query/restriction/RestrictionTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/query/restriction/RestrictionTest.java
@@ -18,7 +18,7 @@
 
 import static org.hibernate.query.Order.asc;
 import static org.hibernate.query.Order.desc;
-import static org.hibernate.query.Path.root;
+import static org.hibernate.query.Path.from;
 import static org.hibernate.query.Restriction.all;
 import static org.hibernate.query.Restriction.any;
 import static org.hibernate.query.Restriction.between;
@@ -42,7 +42,7 @@ public class RestrictionTest {
 
 	@Test
 	void test(SessionFactoryScope scope) {
-		scope.inTransaction( session -> session.createMutationQuery("delete Book").executeUpdate() );
+		scope.getSessionFactory().getSchemaManager().truncate();
 		scope.inTransaction( session -> {
 			session.persist(new Book("9781932394153", "Hibernate in Action", 400));
 			session.persist(new Book("9781617290459", "Java Persistence with Hibernate", 1000));
@@ -149,7 +149,7 @@ void test(SessionFactoryScope scope) {
 
 	@Test
 	void testPath(SessionFactoryScope scope) {
-		scope.inTransaction( session -> session.createMutationQuery( "delete Book" ).executeUpdate() );
+		scope.getSessionFactory().getSchemaManager().truncate();
 		scope.inTransaction( session -> {
 			Publisher pub = new Publisher();
 			pub.name = "Manning";
@@ -173,29 +173,47 @@ void testPath(SessionFactoryScope scope) {
 		@SuppressWarnings( "unchecked" )
 		var version = (SingularAttribute<? super Publisher, Integer>) pubType.findSingularAttribute("version");
 
+		scope.fromSession( session ->
+				session.createSelectionQuery( "from Book", Book.class)
+						.addRestriction( from(Book.class).equalTo( session.find(Book.class, "9781932394153") ) )
+						.getSingleResult() );
+
+		List<Book> booksInIsbn = scope.fromSession( session ->
+				session.createSelectionQuery( "from Book", Book.class)
+						.addRestriction( from(Book.class).to(isbn).in( List.of("9781932394153", "9781617290459") ) )
+						.setOrder( desc( isbn ) )
+						.getResultList() );
+		assertEquals( 2, booksInIsbn.size() );
 		List<Book> booksWithPub = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( root(publisher).get(name).equalTo("Manning") )
+						.addRestriction( from(Book.class).to(publisher).to(name).equalTo("Manning") )
 						.setOrder( desc( title ) )
 						.getResultList() );
 		assertEquals( 2, booksWithPub.size() );
 		List<Book> noBookWithPub = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( root(publisher).get(name).notEqualTo("Manning") )
+						.addRestriction( from(Book.class).to(publisher).to(name).notEqualTo("Manning") )
 						.setOrder( desc( title ) )
 						.getResultList() );
 		assertEquals( 0, noBookWithPub.size() );
 		List<Book> books = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( root(title).restrict( containing("hibernate", false) ) )
+						.addRestriction( from(Book.class).to(title).restrict( containing("hibernate", false) ) )
 						.setOrder( desc( title ) )
 						.getResultList() );
 		assertEquals( 2, books.size() );
 		List<Book> booksWithPubVersion = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( root(publisher).get(version).restrict( greaterThan(5) ) )
+						.addRestriction( from(Book.class).to(publisher).to(version).restrict( greaterThan(5) ) )
 						.getResultList() );
 		assertEquals( 0, booksWithPubVersion.size() );
+		List<Book> unsafeTest = scope.fromSession( session ->
+				session.createSelectionQuery( "from Book", Book.class)
+						.addRestriction( from(Book.class)
+								.to("publisher", Publisher.class)
+								.to("name", String.class).equalTo("Manning") )
+						.getResultList() );
+		assertEquals( 2, unsafeTest.size() );
 	}
 
 	@Entity(name="Book")

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,8 @@`
`13`	`13`	`import org.hibernate.query.range.Range;`
`14`	`14`
`15`	`15`	`/**`
`16`		`- * Restricts an attribute of an entity to a given {@link Range}.`
	`16`	`+ * Restricts an attribute of an entity to a given {@link Range},`
	`17`	`+ * using a stringly-typed attribute reference.`
`17`	`18`	`*`
`18`	`19`	`* @param <X> The entity type`
`19`	`20`	`* @param <U> The attribute type`
`@@ -36,9 +37,10 @@ public Predicate toPredicate(Root<? extends X> root, CriteriaBuilder builder) {`
`36`	`37`	`if ( !(attribute instanceof SingularAttribute) ) {`
`37`	`38`	`throw new IllegalArgumentException( "Attribute '" + attributeName + "' is not singular" );`
`38`	`39`	`}`
`39`		`- if ( range.getType()!=null && !range.getType().isAssignableFrom( attribute.getJavaType() ) ) {`
	`40`	`+ final Class<? extends U> rangeType = range.getType();`
	`41`	`+ if ( rangeType != null && !rangeType.isAssignableFrom( attribute.getJavaType() ) ) {`
`40`	`42`	`throw new IllegalArgumentException( "Attribute '" + attributeName`
`41`		`- + "' is not assignable to range of type '" + range.getType().getName() + "'" );`
	`43`	`+ + "' is not assignable to range of type '" + rangeType.getName() + "'" );`
`42`	`44`	`}`
`43`	`45`	`return range.toPredicate( root.get( attributeName ), builder );`
`44`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`	`*`
`18`	`18`	`* @author Gavin King`
`19`	`19`	`*/`
`20`		`-record PathRange<X, U>(Path<X, U> path, Range<U> range) implements Restriction<X> {`
	`20`	`+record PathRange<X, U>(Path<X, U> path, Range<? super U> range) implements Restriction<X> {`
`21`	`21`	`@Override`
`22`	`22`	`public Restriction<X> negated() {`
`23`	`23`	`return new Negation<>( this );`
Original file line number	Diff line number	Diff line change
`@@ -203,6 +203,10 @@ static <T> Restriction<T> notContains(SingularAttribute<T, String> attribute, St`
`203`	`203`	`return contains( attribute, substring, caseSensitive ).negated();`
`204`	`204`	`}`
`205`	`205`
	`206`	`+ static <T, U> Restriction<T> notNull(SingularAttribute<T, U> attribute) {`
	`207`	`+ return restrict( attribute, Range.notNull( attribute.getJavaType() ) );`
	`208`	`+ }`
	`209`	`+`
`206`	`210`	`static <T> Restriction<T> all(List<? extends Restriction<? super T>> restrictions) {`
`207`	`211`	`return new Conjunction<>( restrictions );`
`208`	`212`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,12 +15,12 @@`
`15`	`15`	`*/`
`16`	`16`	`record EmptyRange<U>(Class<U> type) implements Range<U> {`
`17`	`17`	`@Override`
`18`		`- public Class<? extends U> getType() {`
	`18`	`+ public Class<U> getType() {`
`19`	`19`	`return type;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`@Override`
`23`		`- public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {`
	`23`	`+ public Predicate toPredicate(Path<? extends U> path, CriteriaBuilder builder) {`
`24`	`24`	`return builder.disjunction();`
`25`	`25`	`}`
`26`	`26`	`}`