HHH-18979 rename to ValueList

gavinking · gavinking · commit cdf2c94b0798 · 2024-12-25T10:17:31.000+01:00
and fix whitespace
diff --git a/hibernate-core/src/main/java/org/hibernate/query/Restriction.java b/hibernate-core/src/main/java/org/hibernate/query/Restriction.java
@@ -37,7 +37,6 @@
  * @author Gavin King
  *
  * @since 7.0
- *
  */
 @Incubating
 public interface Restriction<X> {
@@ -54,77 +53,77 @@ public interface Restriction<X> {
 	@Internal
 	Predicate toPredicate(Root<? extends X> root, CriteriaBuilder builder);
 
-	static <T,U> Restriction<T> restrict(SingularAttribute<T,U> attribute, Range<U> range) {
+	static <T, U> Restriction<T> restrict(SingularAttribute<T, U> attribute, Range<U> range) {
 		return new AttributeRange<>( attribute, range );
 	}
 
-	static <T,U> Restriction<T> equal(SingularAttribute<T,U> attribute, U value) {
-		return restrict( attribute, Range.singleValue(value) );
+	static <T, U> Restriction<T> equal(SingularAttribute<T, U> attribute, U value) {
+		return restrict( attribute, Range.singleValue( value ) );
 	}
 
-	static <T,U> Restriction<T> unequal(SingularAttribute<T,U> attribute, U value) {
-		return equal(attribute, value).negated();
+	static <T, U> Restriction<T> unequal(SingularAttribute<T, U> attribute, U value) {
+		return equal( attribute, value ).negated();
 	}
 
-	static <T> Restriction<T> equalIgnoringCase(SingularAttribute<T,String> attribute, String value) {
-		return restrict( attribute, Range.singleCaseInsensitiveValue(value) );
+	static <T> Restriction<T> equalIgnoringCase(SingularAttribute<T, String> attribute, String value) {
+		return restrict( attribute, Range.singleCaseInsensitiveValue( value ) );
 	}
 
-	static <T,U> Restriction<T> in(SingularAttribute<T,U> attribute, java.util.List<U> values) {
-		return restrict( attribute, Range.valueList(values) );
+	static <T, U> Restriction<T> in(SingularAttribute<T, U> attribute, java.util.List<U> values) {
+		return restrict( attribute, Range.valueList( values ) );
 	}
 
-	static <T,U> Restriction<T> notIn(SingularAttribute<T,U> attribute, java.util.List<U> values) {
-		return in(attribute, values).negated();
+	static <T, U> Restriction<T> notIn(SingularAttribute<T, U> attribute, java.util.List<U> values) {
+		return in( attribute, values ).negated();
 	}
 
-	static <T,U extends Comparable<U>> Restriction<T> between(SingularAttribute<T,U> attribute, U lowerBound, U upperBound) {
-		return restrict( attribute, Range.closed(lowerBound, upperBound) );
+	static <T, U extends Comparable<U>> Restriction<T> between(SingularAttribute<T, U> attribute, U lowerBound, U upperBound) {
+		return restrict( attribute, Range.closed( lowerBound, upperBound ) );
 	}
 
-	static <T,U extends Comparable<U>> Restriction<T> notBetween(SingularAttribute<T,U> attribute, U lowerBound, U upperBound) {
-		return between(attribute, lowerBound, upperBound).negated();
+	static <T, U extends Comparable<U>> Restriction<T> notBetween(SingularAttribute<T, U> attribute, U lowerBound, U upperBound) {
+		return between( attribute, lowerBound, upperBound ).negated();
 	}
 
-	static <T,U extends Comparable<U>> Restriction<T> greaterThan(SingularAttribute<T,U> attribute, U lowerBound) {
-		return restrict( attribute, Range.greaterThan(lowerBound) );
+	static <T, U extends Comparable<U>> Restriction<T> greaterThan(SingularAttribute<T, U> attribute, U lowerBound) {
+		return restrict( attribute, Range.greaterThan( lowerBound ) );
 	}
 
-	static <T,U extends Comparable<U>> Restriction<T> lessThan(SingularAttribute<T,U> attribute, U upperBound) {
-		return restrict( attribute, Range.lessThan(upperBound) );
+	static <T, U extends Comparable<U>> Restriction<T> lessThan(SingularAttribute<T, U> attribute, U upperBound) {
+		return restrict( attribute, Range.lessThan( upperBound ) );
 	}
 
-	static <T,U extends Comparable<U>> Restriction<T> greaterThanOrEqual(SingularAttribute<T,U> attribute, U lowerBound) {
-		return restrict( attribute, Range.greaterThanOrEqualTo(lowerBound) );
+	static <T, U extends Comparable<U>> Restriction<T> greaterThanOrEqual(SingularAttribute<T, U> attribute, U lowerBound) {
+		return restrict( attribute, Range.greaterThanOrEqualTo( lowerBound ) );
 	}
 
-	static <T,U extends Comparable<U>> Restriction<T> lessThanOrEqual(SingularAttribute<T,U> attribute, U upperBound) {
-		return restrict( attribute, Range.lessThanOrEqualTo(upperBound) );
+	static <T, U extends Comparable<U>> Restriction<T> lessThanOrEqual(SingularAttribute<T, U> attribute, U upperBound) {
+		return restrict( attribute, Range.lessThanOrEqualTo( upperBound ) );
 	}
 
-	static <T> Restriction<T> like(SingularAttribute<T,String> attribute, String pattern, boolean caseSensitive) {
-		return restrict( attribute, Range.pattern(pattern, caseSensitive) );
+	static <T> Restriction<T> like(SingularAttribute<T, String> attribute, String pattern, boolean caseSensitive) {
+		return restrict( attribute, Range.pattern( pattern, caseSensitive ) );
 	}
 
-	static <T> Restriction<T> like(SingularAttribute<T,String> attribute, String pattern) {
-		return like(attribute, pattern, true);
+	static <T> Restriction<T> like(SingularAttribute<T, String> attribute, String pattern) {
+		return like( attribute, pattern, true );
 	}
 
-	static <T> Restriction<T> notLike(SingularAttribute<T,String> attribute, String pattern) {
-		return like(attribute, pattern, true).negated();
+	static <T> Restriction<T> notLike(SingularAttribute<T, String> attribute, String pattern) {
+		return like( attribute, pattern, true ).negated();
 	}
 
-	static <T> Restriction<T> notLike(SingularAttribute<T,String> attribute, String pattern, boolean caseSensitive) {
-		return like(attribute, pattern, caseSensitive).negated();
+	static <T> Restriction<T> notLike(SingularAttribute<T, String> attribute, String pattern, boolean caseSensitive) {
+		return like( attribute, pattern, caseSensitive ).negated();
 	}
 
 	@SafeVarargs
 	static <T> Restriction<T> and(Restriction<T>... restrictions) {
-		return new Conjunction<>( java.util.List.of(restrictions) );
+		return new Conjunction<>( java.util.List.of( restrictions ) );
 	}
 
 	@SafeVarargs
 	static <T> Restriction<T> or(Restriction<T>... restrictions) {
-		return new Disjunction<>( java.util.List.of(restrictions) );
+		return new Disjunction<>( java.util.List.of( restrictions ) );
 	}
 }
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
@@ -12,6 +12,8 @@
 import org.hibernate.Internal;
 import org.hibernate.query.Restriction;
 
+import java.util.List;
+
 /**
  * Specifies an allowed set of range of values for a value being restricted.
  *
@@ -32,7 +34,7 @@ public interface Range<U> {
 	 * values.
 	 */
 	@Internal
-	<X> Predicate toPredicate(Path<? extends X> root, SingularAttribute<X,U> attribute, CriteriaBuilder builder);
+	<X> Predicate toPredicate(Path<? extends X> root, SingularAttribute<X, U> attribute, CriteriaBuilder builder);
 
 	static <U> Range<U> singleValue(U value) {
 		return new Value<>( value );
@@ -42,8 +44,8 @@ static Range<String> singleCaseInsensitiveValue(String value) {
 		return new CaseInsensitiveValue( value );
 	}
 
-	static <U> Range<U> valueList(java.util.List<U> values) {
-		return new List<>( values );
+	static <U> Range<U> valueList(List<U> values) {
+		return new ValueList<>( values );
 	}
 
 	static <U extends Comparable<U>> Range<U> greaterThan(U bound) {
@@ -66,12 +68,13 @@ static <U extends Comparable<U>> Range<U> open(U lowerBound, U upperBound) {
 		return new Interval<>( new LowerBound<>( lowerBound, true ),
 				new UpperBound<>( upperBound, true ) );
 	}
+
 	static <U extends Comparable<U>> Range<U> closed(U lowerBound, U upperBound) {
 		return new Interval<>( new LowerBound<>( lowerBound, false ),
 				new UpperBound<>( upperBound, false ) );
 	}
 
 	static Range<String> pattern(String pattern, boolean caseSensitive) {
-		return new Pattern(pattern, caseSensitive);
+		return new Pattern( pattern, caseSensitive );
 	}
 }
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
@@ -9,10 +9,12 @@
 import jakarta.persistence.criteria.Predicate;
 import jakarta.persistence.metamodel.SingularAttribute;
 
+import java.util.List;
+
 /**
  * Restricts to a list of literal values.
  */
-record List<U>(java.util.List<U> values) implements Range<U> {
+record ValueList<U>(List<U> values) implements Range<U> {
 	@Override
 	public <X> Predicate toPredicate(Path<? extends X> root, SingularAttribute<X, U> attribute, CriteriaBuilder builder) {
 		return root.get( attribute ).in( values.stream().map( builder::literal ).toList() );

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,6 @@`
`37`	`37`	`* @author Gavin King`
`38`	`38`	`*`
`39`	`39`	`* @since 7.0`
`40`		`- *`
`41`	`40`	`*/`
`42`	`41`	`@Incubating`
`43`	`42`	`public interface Restriction<X> {`
`@@ -54,77 +53,77 @@ public interface Restriction<X> {`
`54`	`53`	`@Internal`
`55`	`54`	`Predicate toPredicate(Root<? extends X> root, CriteriaBuilder builder);`
`56`	`55`
`57`		`- static <T,U> Restriction<T> restrict(SingularAttribute<T,U> attribute, Range<U> range) {`
	`56`	`+ static <T, U> Restriction<T> restrict(SingularAttribute<T, U> attribute, Range<U> range) {`
`58`	`57`	`return new AttributeRange<>( attribute, range );`
`59`	`58`	`}`
`60`	`59`
`61`		`- static <T,U> Restriction<T> equal(SingularAttribute<T,U> attribute, U value) {`
`62`		`- return restrict( attribute, Range.singleValue(value) );`
	`60`	`+ static <T, U> Restriction<T> equal(SingularAttribute<T, U> attribute, U value) {`
	`61`	`+ return restrict( attribute, Range.singleValue( value ) );`
`63`	`62`	`}`
`64`	`63`
`65`		`- static <T,U> Restriction<T> unequal(SingularAttribute<T,U> attribute, U value) {`
`66`		`- return equal(attribute, value).negated();`
	`64`	`+ static <T, U> Restriction<T> unequal(SingularAttribute<T, U> attribute, U value) {`
	`65`	`+ return equal( attribute, value ).negated();`
`67`	`66`	`}`
`68`	`67`
`69`		`- static <T> Restriction<T> equalIgnoringCase(SingularAttribute<T,String> attribute, String value) {`
`70`		`- return restrict( attribute, Range.singleCaseInsensitiveValue(value) );`
	`68`	`+ static <T> Restriction<T> equalIgnoringCase(SingularAttribute<T, String> attribute, String value) {`
	`69`	`+ return restrict( attribute, Range.singleCaseInsensitiveValue( value ) );`
`71`	`70`	`}`
`72`	`71`
`73`		`- static <T,U> Restriction<T> in(SingularAttribute<T,U> attribute, java.util.List<U> values) {`
`74`		`- return restrict( attribute, Range.valueList(values) );`
	`72`	`+ static <T, U> Restriction<T> in(SingularAttribute<T, U> attribute, java.util.List<U> values) {`
	`73`	`+ return restrict( attribute, Range.valueList( values ) );`
`75`	`74`	`}`
`76`	`75`
`77`		`- static <T,U> Restriction<T> notIn(SingularAttribute<T,U> attribute, java.util.List<U> values) {`
`78`		`- return in(attribute, values).negated();`
	`76`	`+ static <T, U> Restriction<T> notIn(SingularAttribute<T, U> attribute, java.util.List<U> values) {`
	`77`	`+ return in( attribute, values ).negated();`
`79`	`78`	`}`
`80`	`79`
`81`		`- static <T,U extends Comparable<U>> Restriction<T> between(SingularAttribute<T,U> attribute, U lowerBound, U upperBound) {`
`82`		`- return restrict( attribute, Range.closed(lowerBound, upperBound) );`
	`80`	`+ static <T, U extends Comparable<U>> Restriction<T> between(SingularAttribute<T, U> attribute, U lowerBound, U upperBound) {`
	`81`	`+ return restrict( attribute, Range.closed( lowerBound, upperBound ) );`
`83`	`82`	`}`
`84`	`83`
`85`		`- static <T,U extends Comparable<U>> Restriction<T> notBetween(SingularAttribute<T,U> attribute, U lowerBound, U upperBound) {`
`86`		`- return between(attribute, lowerBound, upperBound).negated();`
	`84`	`+ static <T, U extends Comparable<U>> Restriction<T> notBetween(SingularAttribute<T, U> attribute, U lowerBound, U upperBound) {`
	`85`	`+ return between( attribute, lowerBound, upperBound ).negated();`
`87`	`86`	`}`
`88`	`87`
`89`		`- static <T,U extends Comparable<U>> Restriction<T> greaterThan(SingularAttribute<T,U> attribute, U lowerBound) {`
`90`		`- return restrict( attribute, Range.greaterThan(lowerBound) );`
	`88`	`+ static <T, U extends Comparable<U>> Restriction<T> greaterThan(SingularAttribute<T, U> attribute, U lowerBound) {`
	`89`	`+ return restrict( attribute, Range.greaterThan( lowerBound ) );`
`91`	`90`	`}`
`92`	`91`
`93`		`- static <T,U extends Comparable<U>> Restriction<T> lessThan(SingularAttribute<T,U> attribute, U upperBound) {`
`94`		`- return restrict( attribute, Range.lessThan(upperBound) );`
	`92`	`+ static <T, U extends Comparable<U>> Restriction<T> lessThan(SingularAttribute<T, U> attribute, U upperBound) {`
	`93`	`+ return restrict( attribute, Range.lessThan( upperBound ) );`
`95`	`94`	`}`
`96`	`95`
`97`		`- static <T,U extends Comparable<U>> Restriction<T> greaterThanOrEqual(SingularAttribute<T,U> attribute, U lowerBound) {`
`98`		`- return restrict( attribute, Range.greaterThanOrEqualTo(lowerBound) );`
	`96`	`+ static <T, U extends Comparable<U>> Restriction<T> greaterThanOrEqual(SingularAttribute<T, U> attribute, U lowerBound) {`
	`97`	`+ return restrict( attribute, Range.greaterThanOrEqualTo( lowerBound ) );`
`99`	`98`	`}`
`100`	`99`
`101`		`- static <T,U extends Comparable<U>> Restriction<T> lessThanOrEqual(SingularAttribute<T,U> attribute, U upperBound) {`
`102`		`- return restrict( attribute, Range.lessThanOrEqualTo(upperBound) );`
	`100`	`+ static <T, U extends Comparable<U>> Restriction<T> lessThanOrEqual(SingularAttribute<T, U> attribute, U upperBound) {`
	`101`	`+ return restrict( attribute, Range.lessThanOrEqualTo( upperBound ) );`
`103`	`102`	`}`
`104`	`103`
`105`		`- static <T> Restriction<T> like(SingularAttribute<T,String> attribute, String pattern, boolean caseSensitive) {`
`106`		`- return restrict( attribute, Range.pattern(pattern, caseSensitive) );`
	`104`	`+ static <T> Restriction<T> like(SingularAttribute<T, String> attribute, String pattern, boolean caseSensitive) {`
	`105`	`+ return restrict( attribute, Range.pattern( pattern, caseSensitive ) );`
`107`	`106`	`}`
`108`	`107`
`109`		`- static <T> Restriction<T> like(SingularAttribute<T,String> attribute, String pattern) {`
`110`		`- return like(attribute, pattern, true);`
	`108`	`+ static <T> Restriction<T> like(SingularAttribute<T, String> attribute, String pattern) {`
	`109`	`+ return like( attribute, pattern, true );`
`111`	`110`	`}`
`112`	`111`
`113`		`- static <T> Restriction<T> notLike(SingularAttribute<T,String> attribute, String pattern) {`
`114`		`- return like(attribute, pattern, true).negated();`
	`112`	`+ static <T> Restriction<T> notLike(SingularAttribute<T, String> attribute, String pattern) {`
	`113`	`+ return like( attribute, pattern, true ).negated();`
`115`	`114`	`}`
`116`	`115`
`117`		`- static <T> Restriction<T> notLike(SingularAttribute<T,String> attribute, String pattern, boolean caseSensitive) {`
`118`		`- return like(attribute, pattern, caseSensitive).negated();`
	`116`	`+ static <T> Restriction<T> notLike(SingularAttribute<T, String> attribute, String pattern, boolean caseSensitive) {`
	`117`	`+ return like( attribute, pattern, caseSensitive ).negated();`
`119`	`118`	`}`
`120`	`119`
`121`	`120`	`@SafeVarargs`
`122`	`121`	`static <T> Restriction<T> and(Restriction<T>... restrictions) {`
`123`		`- return new Conjunction<>( java.util.List.of(restrictions) );`
	`122`	`+ return new Conjunction<>( java.util.List.of( restrictions ) );`
`124`	`123`	`}`
`125`	`124`
`126`	`125`	`@SafeVarargs`
`127`	`126`	`static <T> Restriction<T> or(Restriction<T>... restrictions) {`
`128`		`- return new Disjunction<>( java.util.List.of(restrictions) );`
	`127`	`+ return new Disjunction<>( java.util.List.of( restrictions ) );`
`129`	`128`	`}`
`130`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@`
`12`	`12`	`import org.hibernate.Internal;`
`13`	`13`	`import org.hibernate.query.Restriction;`
`14`	`14`
	`15`	`+import java.util.List;`
	`16`	`+`
`15`	`17`	`/**`
`16`	`18`	`* Specifies an allowed set of range of values for a value being restricted.`
`17`	`19`	`*`
`@@ -32,7 +34,7 @@ public interface Range<U> {`
`32`	`34`	`* values.`
`33`	`35`	`*/`
`34`	`36`	`@Internal`
`35`		`- <X> Predicate toPredicate(Path<? extends X> root, SingularAttribute<X,U> attribute, CriteriaBuilder builder);`
	`37`	`+ <X> Predicate toPredicate(Path<? extends X> root, SingularAttribute<X, U> attribute, CriteriaBuilder builder);`
`36`	`38`
`37`	`39`	`static <U> Range<U> singleValue(U value) {`
`38`	`40`	`return new Value<>( value );`
`@@ -42,8 +44,8 @@ static Range<String> singleCaseInsensitiveValue(String value) {`
`42`	`44`	`return new CaseInsensitiveValue( value );`
`43`	`45`	`}`
`44`	`46`
`45`		`- static <U> Range<U> valueList(java.util.List<U> values) {`
`46`		`- return new List<>( values );`
	`47`	`+ static <U> Range<U> valueList(List<U> values) {`
	`48`	`+ return new ValueList<>( values );`
`47`	`49`	`}`
`48`	`50`
`49`	`51`	`static <U extends Comparable<U>> Range<U> greaterThan(U bound) {`
`@@ -66,12 +68,13 @@ static <U extends Comparable<U>> Range<U> open(U lowerBound, U upperBound) {`
`66`	`68`	`return new Interval<>( new LowerBound<>( lowerBound, true ),`
`67`	`69`	`new UpperBound<>( upperBound, true ) );`
`68`	`70`	`}`
	`71`	`+`
`69`	`72`	`static <U extends Comparable<U>> Range<U> closed(U lowerBound, U upperBound) {`
`70`	`73`	`return new Interval<>( new LowerBound<>( lowerBound, false ),`
`71`	`74`	`new UpperBound<>( upperBound, false ) );`
`72`	`75`	`}`
`73`	`76`
`74`	`77`	`static Range<String> pattern(String pattern, boolean caseSensitive) {`
`75`		`- return new Pattern(pattern, caseSensitive);`
	`78`	`+ return new Pattern( pattern, caseSensitive );`
`76`	`79`	`}`
`77`	`80`	`}`