HHH-18979 work on some details

Author: gavinking

hibernate-core/src/main/java/org/hibernate/query/NamedAttributeRange.java

@@ -34,7 +34,7 @@ public Predicate toPredicate(Root<? extends X> root, CriteriaBuilder builder) {
 		if ( !(attribute instanceof SingularAttribute) ) {
 			throw new IllegalArgumentException( "Attribute '" + attributeName + "' is not singular" );
 		}
-		if ( !range.getType().isAssignableFrom( attribute.getJavaType() ) ) {
+		if ( range.getType()!=null && !range.getType().isAssignableFrom( attribute.getJavaType() ) ) {
 			throw new IllegalArgumentException( "Attribute '" + attributeName
 					+ "' is not assignable to range of type '" + range.getType().getName() + "'" );
 		}

hibernate-core/src/main/java/org/hibernate/query/Restriction.java

@@ -24,6 +24,9 @@
  *         .setOrder(Order.desc(Book_.title))
  * 		   .getResultList() );
  * </pre>
+ * <p>
+ * Each restriction pairs an {@linkplain SingularAttribute attribute} of the
+ * entity with a {@link Range} of allowed values for the attribute.
  *
  * @param <X> The entity result type of the query
  *
@@ -53,10 +56,21 @@ public interface Restriction<X> {
 	@Internal
 	Predicate toPredicate(Root<? extends X> root, CriteriaBuilder builder);
 
+	/**
+	 * Restrict the allowed values of the given attribute to the given
+	 * {@linkplain Range range}.
+	 */
 	static <T, U> Restriction<T> restrict(SingularAttribute<T, U> attribute, Range<U> range) {
 		return new AttributeRange<>( attribute, range );
 	}
 
+	/**
+	 * Restrict the allowed values of the named attribute of the given
+	 * entity class to the given {@linkplain Range range}.
+	 * <p>
+	 * This operation is not compile-time type safe. Prefer the use of
+	 * {@link #restrict(SingularAttribute, Range)}.
+	 */
 	static <T> Restriction<T> restrict(Class<T> type, String attributeName, Range<?> range) {
 		return new NamedAttributeRange<>( type, attributeName, range );
 	}
@@ -131,26 +145,7 @@ static <T> Restriction<T> or(Restriction<T>... restrictions) {
 		return new Disjunction<>( java.util.List.of( restrictions ) );
 	}
 
-	static <T> Restriction<T> none() {
-		return new Restriction<>() {
-			final Restriction<T> none = this;
-			@Override
-			public Restriction<T> negated() {
-				return new Restriction<>() {
-					@Override
-					public Predicate toPredicate(Root<? extends T> root, CriteriaBuilder builder) {
-						return builder.disjunction();
-					}
-					@Override
-					public Restriction<T> negated() {
-						return none;
-					}
-				};
-			}
-			@Override
-			public Predicate toPredicate(Root<? extends T> root, CriteriaBuilder builder) {
-				return builder.conjunction();
-			}
-		};
+	static <T> Restriction<T> unrestricted() {
+		return new Unrestricted<>();
 	}
 }

hibernate-core/src/main/java/org/hibernate/query/Unrestricted.java

@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.query;
+
+import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.Predicate;
+import jakarta.persistence.criteria.Root;
+
+/**
+ * A null restriction.
+ */
+public class Unrestricted<T> implements Restriction<T> {
+	@Override
+	public Restriction<T> negated() {
+		return new Restriction<>() {
+			@Override
+			public Predicate toPredicate(Root<? extends T> root, CriteriaBuilder builder) {
+				return builder.disjunction();
+			}
+
+			@Override
+			public Restriction<T> negated() {
+				return Unrestricted.this;
+			}
+		};
+	}
+
+	@Override
+	public Predicate toPredicate(Root<? extends T> root, CriteriaBuilder builder) {
+		return builder.conjunction();
+	}
+}

hibernate-core/src/main/java/org/hibernate/query/range/CaseInsensitiveValue.java

@@ -10,11 +10,16 @@
 import jakarta.persistence.criteria.Predicate;
 
 import java.util.Locale;
+import java.util.Objects;
 
 /**
- * Restricts to a single literal string, ignoring case.
+ * A {@link Range} with a single literal string, ignoring case.
  */
 record CaseInsensitiveValue(String value) implements Range<String> {
+	CaseInsensitiveValue {
+		Objects.requireNonNull( value, "value is null" );
+	}
+
 	@Override
 	public Predicate toPredicate(Path<String> path, CriteriaBuilder builder) {
 		// TODO: it would be much better to not do use literal,

hibernate-core/src/main/java/org/hibernate/query/range/EmptyRange.java

@@ -0,0 +1,24 @@
+/*
+ * 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 no values.
+ */
+record EmptyRange<U>(Class<U> type) implements Range<U> {
+	@Override
+	public Class<? extends U> getType() {
+		return type;
+	}
+
+	@Override
+	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+		return builder.disjunction();
+	}
+}

hibernate-core/src/main/java/org/hibernate/query/range/FullRange.java

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+record FullRange<U>(Class<U> type) implements Range<U> {
+	@Override
+	public Class<? extends U> getType() {
+		return type;
+	}
+
+	@Override
+	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
+		return builder.conjunction();
+	}
+}

hibernate-core/src/main/java/org/hibernate/query/range/Interval.java

@@ -9,7 +9,7 @@
 import jakarta.persistence.criteria.Predicate;
 
 /**
- * Restricts to an upper-bounded and lower-bounded interval.
+ * An upper-bounded and lower-bounded interval.
  */
 record Interval<U extends Comparable<U>>(LowerBound<U> lowerBound, UpperBound<U> upperBound)
 		implements Range<U> {

hibernate-core/src/main/java/org/hibernate/query/range/LowerBound.java

@@ -9,10 +9,16 @@
 import jakarta.persistence.criteria.Path;
 import jakarta.persistence.criteria.Predicate;
 
+import java.util.Objects;
+
 /**
- * Restricts to all values higher than a given lower bound.
+ * The {@link Range} of all values above a given lower bound.
  */
 record LowerBound<U extends Comparable<U>>(U bound, boolean open) implements Range<U> {
+	LowerBound {
+		Objects.requireNonNull( bound, "bound is null" );
+	}
+
 	@Override
 	public Predicate toPredicate(Path<U> path, CriteriaBuilder builder) {
 		// TODO: it would be much better to not do use literal,

hibernate-core/src/main/java/org/hibernate/query/range/Pattern.java

@@ -11,7 +11,7 @@
 import java.util.Locale;
 
 /**
- * Restricts a string by a pattern.
+ * The {@link Range} of strings recognized by the given pattern.
  */
 record Pattern(String pattern, boolean caseSensitive) implements Range<String> {
 	@Override

hibernate-core/src/main/java/org/hibernate/query/range/Range.java

@@ -78,4 +78,12 @@ static <U extends Comparable<U>> Range<U> closed(U lowerBound, U upperBound) {
 	static Range<String> pattern(String pattern, boolean caseSensitive) {
 		return new Pattern( pattern, caseSensitive );
 	}
+
+	static <U> Range<U> empty(Class<U> type) {
+		return new EmptyRange<>( type );
+	}
+
+	static <U> Range<U> full(Class<U> type) {
+		return new FullRange<>( type );
+	}
 }