RestrictionBuilder (Blazebit Persistence Core API 1.3.1 API)

Type Parameters:

T - The builder type that is returned on terminal operations

All Known Subinterfaces:

RestrictionBuilderExperimental<T>
```
public interface RestrictionBuilder<T>
```
The builder interface for predicates. The left hand side of the predicate is already known to the builder and the methods of this builder either terminate the building process or start a SubqueryInitiator.

Since:

1.0.0

Author:

Christian Beikov

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`BetweenBuilder<T>`	`between(Object start)`	Starts a builder for a between predicate with parameterized lower bound.
`BetweenBuilder<T>`	`betweenExpression(String start)`	Starts a builder for a between predicate with lower bound expression.
`MultipleSubqueryInitiator<BetweenBuilder<T>>`	`betweenSubqueries(String expression)`	Starts a `MultipleSubqueryInitiator` for a between predicate with the given expression as lower bound.
`SubqueryInitiator<BetweenBuilder<T>>`	`betweenSubquery()`	Starts a builder for a between predicate with a subquery as lower bound.
`SubqueryBuilder<BetweenBuilder<T>>`	`betweenSubquery(FullQueryBuilder<?,?> criteriaBuilder)`	Starts a builder for a between predicate with a subquery as lower bound.
`SubqueryInitiator<BetweenBuilder<T>>`	`betweenSubquery(String subqueryAlias, String expression)`	Starts a builder for a between predicate with a subquery as lower bound.
`SubqueryBuilder<BetweenBuilder<T>>`	`betweenSubquery(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Starts a builder for a between predicate with a subquery as lower bound.
`QuantifiableBinaryPredicateBuilder<T>`	`eq()`	Starts a `QuantifiableBinaryPredicateBuilder` for the EQ predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`eq(FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the right hand side for the EQ predicate.
`T`	`eq(Object value)`	Finishes the EQ predicate and adds it to the parent predicate container represented by the type `T`.
`SubqueryInitiator<T>`	`eq(String subqueryAlias, String expression)`	Starts a `SubqueryInitiator` for the EQ predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`eq(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the EQ predicate that can be used to apply quantors.
`T`	`eqExpression(String expression)`	Finishes the EQ predicate and adds it to the parent predicate container represented by the type `T`.
`MultipleSubqueryInitiator<T>`	`eqSubqueries(String expression)`	Starts a `SubqueryInitiator` for the EQ predicate that can be used to apply quantors.
`QuantifiableBinaryPredicateBuilder<T>`	`ge()`	Starts a `QuantifiableBinaryPredicateBuilder` for the GE predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`ge(FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the GE predicate that can be used to apply quantors.
`T`	`ge(Object value)`	Finishes the GE predicate and adds it to the parent predicate container represented by the type `T`.
`SubqueryInitiator<T>`	`ge(String subqueryAlias, String expression)`	Starts a `SubqueryInitiator` for the GE predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`ge(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the GE predicate that can be used to apply quantors.
`T`	`geExpression(String expression)`	Finishes the GE predicate and adds it to the parent predicate container represented by the type `T`.
`MultipleSubqueryInitiator<T>`	`geSubqueries(String expression)`	Starts a `SubqueryInitiator` for the GE predicate that can be used to apply quantors.
`QuantifiableBinaryPredicateBuilder<T>`	`gt()`	Starts a `QuantifiableBinaryPredicateBuilder` for the GT predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`gt(FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the GT predicate that can be used to apply quantors.
`T`	`gt(Object value)`	Finishes the GT predicate and adds it to the parent predicate container represented by the type `T`.
`SubqueryInitiator<T>`	`gt(String subqueryAlias, String expression)`	Starts a `SubqueryInitiator` for the GT predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`gt(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the GT predicate that can be used to apply quantors.
`T`	`gtExpression(String expression)`	Finishes the GT predicate and adds it to the parent predicate container represented by the type `T`.
`MultipleSubqueryInitiator<T>`	`gtSubqueries(String expression)`	Starts a `SubqueryInitiator` for the GT predicate that can be used to apply quantors.
`SubqueryInitiator<T>`	`in()`	Starts a `SubqueryInitiator` for the right hand side of the IN predicate.
`SubqueryBuilder<T>`	`in(FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the right hand side of the IN predicate.
`T`	`in(Object... values)`	Like `in(java.util.Collection)` but the values will be wrapped in a `Collection`.
`T`	`in(Collection<?> values)`	Finishes the IN predicate and adds it to the parent predicate container represented by the type `T`.
`T`	`inExpressions(String... parameterOrLiteralExpressions)`	Finishes the IN predicate and adds it to the parent predicate container represented by the type `T`.
`T`	`isEmpty()`	Finishes the IS EMPTY predicate and adds it to the parent predicate container represented by the type `T`.
`T`	`isMemberOf(String expression)`	Finishes the MEMBER OF predicate and adds it to the parent predicate container represented by the type `T`.
`T`	`isNotEmpty()`	Like `isEmpty()` but the result is wrapped in a NOT predicate.
`T`	`isNotMemberOf(String expression)`	Like `isMemberOf(java.lang.String)` but the result is wrapped in a NOT predicate.
`T`	`isNotNull()`	Like `isNull()` but the result is wrapped in a NOT predicate.
`T`	`isNull()`	Finishes the IS NULL predicate and adds it to the parent predicate container represented by the type `T`.
`QuantifiableBinaryPredicateBuilder<T>`	`le()`	Starts a `QuantifiableBinaryPredicateBuilder` for the LE predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`le(FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the LE predicate that can be used to apply quantors.
`T`	`le(Object value)`	Finishes the LE predicate and adds it to the parent predicate container represented by the type `T`.
`SubqueryInitiator<T>`	`le(String subqueryAlias, String expression)`	Starts a `SubqueryInitiator` for the LE predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`le(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the LE predicate that can be used to apply quantors.
`T`	`leExpression(String expression)`	Finishes the LE predicate and adds it to the parent predicate container represented by the type `T`.
`MultipleSubqueryInitiator<T>`	`leSubqueries(String expression)`	Starts a `SubqueryInitiator` for the LE predicate that can be used to apply quantors.
`LikeBuilder<T>`	`like()`	Like `like(boolean)` with `caseSensitive = true`.
`LikeBuilder<T>`	`like(boolean caseSensitive)`	Creates a `LikeBuilder` for building a like predicate.
`QuantifiableBinaryPredicateBuilder<T>`	`lt()`	Starts a `QuantifiableBinaryPredicateBuilder` for the LT predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`lt(FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the LT predicate that can be used to apply quantors.
`T`	`lt(Object value)`	Finishes the LT predicate and adds it to the parent predicate container represented by the type `T`.
`SubqueryInitiator<T>`	`lt(String subqueryAlias, String expression)`	Starts a `SubqueryInitiator` for the LT predicate that can be used to apply quantors.
`SubqueryBuilder<T>`	`lt(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Starts a `SubqueryBuilder` based on the given criteria builder for the LT predicate that can be used to apply quantors.
`T`	`ltExpression(String expression)`	Finishes the LT predicate and adds it to the parent predicate container represented by the type `T`.
`MultipleSubqueryInitiator<T>`	`ltSubqueries(String expression)`	Starts a `SubqueryInitiator` for the LT predicate that can be used to apply quantors.
`RestrictionBuilderExperimental<T>`	`nonPortable()`	Switch to the non portable mode which might to be portable to other JPA providers.
`BetweenBuilder<T>`	`notBetween(Object start)`	Like `notBetween(java.lang.Object)` but the resulting predicate is negated.
`BetweenBuilder<T>`	`notBetweenExpression(String start)`	Like `betweenExpression(java.lang.String)` but the resulting predicate is negated.
`MultipleSubqueryInitiator<BetweenBuilder<T>>`	`notBetweenSubqueries(String expression)`	Like `betweenSubqueries(java.lang.String)` but the resulting predicate is negated.
`SubqueryInitiator<BetweenBuilder<T>>`	`notBetweenSubquery()`	Like `betweenSubquery()` but the resulting predicate is negated.
`SubqueryBuilder<BetweenBuilder<T>>`	`notBetweenSubquery(FullQueryBuilder<?,?> criteriaBuilder)`	Like `betweenSubquery(FullQueryBuilder)` but the resulting predicate is negated.
`SubqueryInitiator<BetweenBuilder<T>>`	`notBetweenSubquery(String subqueryAlias, String expression)`	Like `betweenSubquery(java.lang.String, java.lang.String)` but the resulting predicate is negated.
`SubqueryBuilder<BetweenBuilder<T>>`	`notBetweenSubquery(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Like `betweenSubquery(java.lang.String, java.lang.String, FullQueryBuilder)` but the resulting predicate is negated.
`QuantifiableBinaryPredicateBuilder<T>`	`notEq()`	Like `eq()` but the result is wrapped in a NOT predicate.
`SubqueryBuilder<T>`	`notEq(FullQueryBuilder<?,?> criteriaBuilder)`	Like `eq(FullQueryBuilder)` but the result is wrapped in a NOT predicate.
`T`	`notEq(Object value)`	Like `eq(java.lang.Object)` but the result is wrapped in a NOT predicate.
`SubqueryInitiator<T>`	`notEq(String subqueryAlias, String expression)`	Like `eq(java.lang.String,java.lang.String)` but the result is wrapped in a NOT predicate.
`SubqueryBuilder<T>`	`notEq(String subqueryAlias, String expression, FullQueryBuilder<?,?> criteriaBuilder)`	Like `eq(java.lang.String,java.lang.String, FullQueryBuilder)` but the result is wrapped in a NOT predicate.
`T`	`notEqExpression(String expression)`	Like `eqExpression(java.lang.String)` but the result is wrapped in a NOT predicate.
`MultipleSubqueryInitiator<T>`	`notEqSubqueries(String expression)`	Like `eqSubqueries(java.lang.String)` but the result is wrapped in a NOT predicate.
`SubqueryInitiator<T>`	`notIn()`	Like `in()` but the result is wrapped in a NOT predicate.
`SubqueryBuilder<T>`	`notIn(FullQueryBuilder<?,?> criteriaBuilder)`	Like `in(FullQueryBuilder)` but the result is wrapped in a NOT predicate.
`T`	`notIn(Object... values)`	Like `notIn(java.util.Collection)` but the values will be wrapped in a `Collection`.
`T`	`notIn(Collection<?> values)`	Like `in(java.util.Collection)` but the result is wrapped in a NOT predicate.
`T`	`notInExpressions(String... parameterOrLiteralExpressions)`	Like `inExpressions(String...)` but the result is wrapped in a NOT predicate.
`LikeBuilder<T>`	`notLike()`	Like `notLike(boolean)` with `caseSensitive = true`.
`LikeBuilder<T>`	`notLike(boolean caseSensitive)`	Like `like(boolean)` but the resulting like predicate is negated.

- Method Detail
  - betweenExpression
```
BetweenBuilder<T> betweenExpression(String start)
```
    Starts a builder for a between predicate with lower bound expression.
    
    Parameters:
    
    start - The between start expression
    
    Returns:
    
    The BetweenBuilder
  - between
```
BetweenBuilder<T> between(Object start)
```
    Starts a builder for a between predicate with parameterized lower bound.
    
    Parameters:
    
    start - The between start value
    
    Returns:
    
    The BetweenBuilder
  - betweenSubquery
```
SubqueryInitiator<BetweenBuilder<T>> betweenSubquery()
```
    Starts a builder for a between predicate with a subquery as lower bound.
    
    Returns:
    
    The SubqueryInitiator
  - betweenSubquery
```
SubqueryInitiator<BetweenBuilder<T>> betweenSubquery(String subqueryAlias,
                                                     String expression)
```
    Starts a builder for a between predicate with a subquery as lower bound.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the when predicate in conjunction with it's then expression are added to this predicate container as disjunct.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    
    The SubqueryInitiator
  - betweenSubqueries
```
MultipleSubqueryInitiator<BetweenBuilder<T>> betweenSubqueries(String expression)
```
    Starts a MultipleSubqueryInitiator for a between predicate with the given expression as lower bound.
    All occurrences of subsequently defined subqueryAliases in expression will be replaced by the respective subquery. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    expression - The expression for the lower bound of the between predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - betweenSubquery
```
SubqueryBuilder<BetweenBuilder<T>> betweenSubquery(FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a builder for a between predicate with a subquery as lower bound.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - betweenSubquery
```
SubqueryBuilder<BetweenBuilder<T>> betweenSubquery(String subqueryAlias,
                                                   String expression,
                                                   FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a builder for a between predicate with a subquery as lower bound.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the when predicate in conjunction with it's then expression are added to this predicate container as disjunct.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - notBetweenExpression
```
BetweenBuilder<T> notBetweenExpression(String start)
```
    Like betweenExpression(java.lang.String) but the resulting predicate is negated.
    
    Parameters:
    
    start - The between start expression
    
    Returns:
    
    The BetweenBuilder
  - notBetween
```
BetweenBuilder<T> notBetween(Object start)
```
    Like notBetween(java.lang.Object) but the resulting predicate is negated.
    
    Parameters:
    
    start - The between start value
    
    Returns:
    
    The BetweenBuilder
  - notBetweenSubquery
```
SubqueryInitiator<BetweenBuilder<T>> notBetweenSubquery()
```
    Like betweenSubquery() but the resulting predicate is negated.
    
    Returns:
    
    The SubqueryInitiator
  - notBetweenSubquery
```
SubqueryInitiator<BetweenBuilder<T>> notBetweenSubquery(String subqueryAlias,
                                                        String expression)
```
    Like betweenSubquery(java.lang.String, java.lang.String) but the resulting predicate is negated.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    
    The SubqueryInitiator
  - notBetweenSubqueries
```
MultipleSubqueryInitiator<BetweenBuilder<T>> notBetweenSubqueries(String expression)
```
    Like betweenSubqueries(java.lang.String) but the resulting predicate is negated.
    
    Parameters:
    
    expression - The expression for the lower bound of the between predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - notBetweenSubquery
```
SubqueryBuilder<BetweenBuilder<T>> notBetweenSubquery(FullQueryBuilder<?,?> criteriaBuilder)
```
    Like betweenSubquery(FullQueryBuilder) but the resulting predicate is negated.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - notBetweenSubquery
```
SubqueryBuilder<BetweenBuilder<T>> notBetweenSubquery(String subqueryAlias,
                                                      String expression,
                                                      FullQueryBuilder<?,?> criteriaBuilder)
```
    Like betweenSubquery(java.lang.String, java.lang.String, FullQueryBuilder) but the resulting predicate is negated.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - eq
```
QuantifiableBinaryPredicateBuilder<T> eq()
```
    Starts a QuantifiableBinaryPredicateBuilder for the EQ predicate that can be used to apply quantors.
    
    Returns:
    
    The quantifiable binary predicate builder
  - eq
```
SubqueryInitiator<T> eq(String subqueryAlias,
                        String expression)
```
    Starts a SubqueryInitiator for the EQ predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    
    The quantifiable subquery initiator
  - eqSubqueries
```
MultipleSubqueryInitiator<T> eqSubqueries(String expression)
```
    Starts a SubqueryInitiator for the EQ predicate that can be used to apply quantors.
    All occurrences of subsequently defined subqueryAliases in expression will be replaced by the respective subquery. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    expression - The expression for the right hand side of the EQ predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - eq
```
SubqueryBuilder<T> eq(FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the right hand side for the EQ predicate.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - eq
```
SubqueryBuilder<T> eq(String subqueryAlias,
                      String expression,
                      FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the EQ predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - eq
```
T eq(Object value)
```
    Finishes the EQ predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is equal to the given value.
    
    Parameters:
    
    value - The value on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - eqExpression
```
T eqExpression(String expression)
```
    Finishes the EQ predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is equal to the given expression.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - notEq
```
QuantifiableBinaryPredicateBuilder<T> notEq()
```
    Like eq() but the result is wrapped in a NOT predicate.
    
    Returns:
    
    The quantifiable binary predicate builder
  - notEq
```
SubqueryInitiator<T> notEq(String subqueryAlias,
                           String expression)
```
    Like eq(java.lang.String,java.lang.String) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate
    
    Returns:
    
    The quantifiable binary predicate builder
  - notEqSubqueries
```
MultipleSubqueryInitiator<T> notEqSubqueries(String expression)
```
    Like eqSubqueries(java.lang.String) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    expression - The expression for the right hand side of the NOT EQ predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - notEq
```
SubqueryBuilder<T> notEq(FullQueryBuilder<?,?> criteriaBuilder)
```
    Like eq(FullQueryBuilder) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - notEq
```
SubqueryBuilder<T> notEq(String subqueryAlias,
                         String expression,
                         FullQueryBuilder<?,?> criteriaBuilder)
```
    Like eq(java.lang.String,java.lang.String, FullQueryBuilder) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - notEq
```
T notEq(Object value)
```
    Like eq(java.lang.Object) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    value - The value on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - notEqExpression
```
T notEqExpression(String expression)
```
    Like eqExpression(java.lang.String) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The quantifiable binary predicate builder
  - gt
```
QuantifiableBinaryPredicateBuilder<T> gt()
```
    Starts a QuantifiableBinaryPredicateBuilder for the GT predicate that can be used to apply quantors.
    
    Returns:
    
    The quantifiable binary predicate builder
  - gt
```
SubqueryInitiator<T> gt(String subqueryAlias,
                        String expression)
```
    Starts a SubqueryInitiator for the GT predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as right hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    
    The quantifiable subquery initiator
  - gtSubqueries
```
MultipleSubqueryInitiator<T> gtSubqueries(String expression)
```
    Starts a SubqueryInitiator for the GT predicate that can be used to apply quantors.
    All occurrences of subsequently defined subqueryAliases in expression will be replaced by the respective subquery. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    expression - The expression for the right hand side of the GT predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - gt
```
SubqueryBuilder<T> gt(FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the GT predicate that can be used to apply quantors.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - gt
```
SubqueryBuilder<T> gt(String subqueryAlias,
                      String expression,
                      FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the GT predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as right hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - gt
```
T gt(Object value)
```
    Finishes the GT predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is greater than the given value.
    
    Parameters:
    
    value - The value on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - gtExpression
```
T gtExpression(String expression)
```
    Finishes the GT predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is greater than the given expression.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - ge
```
QuantifiableBinaryPredicateBuilder<T> ge()
```
    Starts a QuantifiableBinaryPredicateBuilder for the GE predicate that can be used to apply quantors.
    
    Returns:
    
    The quantifiable binary predicate builder
  - ge
```
SubqueryInitiator<T> ge(String subqueryAlias,
                        String expression)
```
    Starts a SubqueryInitiator for the GE predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    
    The quantifiable subquery initiator
  - geSubqueries
```
MultipleSubqueryInitiator<T> geSubqueries(String expression)
```
    Starts a SubqueryInitiator for the GE predicate that can be used to apply quantors.
    All occurrences of subsequently defined subqueryAliases in expression will be replaced by the respective subquery. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    expression - The expression for the right hand side of the GE predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - ge
```
SubqueryBuilder<T> ge(FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the GE predicate that can be used to apply quantors.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - ge
```
SubqueryBuilder<T> ge(String subqueryAlias,
                      String expression,
                      FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the GE predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - ge
```
T ge(Object value)
```
    Finishes the GE predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is greater or equal to the given value.
    
    Parameters:
    
    value - The value on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - geExpression
```
T geExpression(String expression)
```
    Finishes the GE predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is greater or equal to the given expression.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - lt
```
QuantifiableBinaryPredicateBuilder<T> lt()
```
    Starts a QuantifiableBinaryPredicateBuilder for the LT predicate that can be used to apply quantors.
    
    Returns:
    
    The quantifiable binary predicate builder
  - lt
```
SubqueryInitiator<T> lt(String subqueryAlias,
                        String expression)
```
    Starts a SubqueryInitiator for the LT predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as right hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    
    The quantifiable subquery initiator
  - ltSubqueries
```
MultipleSubqueryInitiator<T> ltSubqueries(String expression)
```
    Starts a SubqueryInitiator for the LT predicate that can be used to apply quantors.
    All occurrences of subsequently defined subqueryAliases in expression will be replaced by the respective subquery. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    expression - The expression for the right hand side of the LT predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - lt
```
SubqueryBuilder<T> lt(FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the LT predicate that can be used to apply quantors.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - lt
```
SubqueryBuilder<T> lt(String subqueryAlias,
                      String expression,
                      FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the LT predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as right hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - lt
```
T lt(Object value)
```
    Finishes the LT predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is less than the given value.
    
    Parameters:
    
    value - The value on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - ltExpression
```
T ltExpression(String expression)
```
    Finishes the LT predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is less than the given expression.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - le
```
QuantifiableBinaryPredicateBuilder<T> le()
```
    Starts a QuantifiableBinaryPredicateBuilder for the LE predicate that can be used to apply quantors.
    
    Returns:
    
    The quantifiable binary predicate builder
  - le
```
SubqueryInitiator<T> le(String subqueryAlias,
                        String expression)
```
    Starts a SubqueryInitiator for the LE predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as right hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    
    The quantifiable subquery initiator
  - leSubqueries
```
MultipleSubqueryInitiator<T> leSubqueries(String expression)
```
    Starts a SubqueryInitiator for the LE predicate that can be used to apply quantors.
    All occurrences of subsequently defined subqueryAliases in expression will be replaced by the respective subquery. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    expression - The expression for the right hand side of the LE predicate.
    
    Returns:
    
    The subquery initiator for building multiple subqueries for their respective subqueryAliases
    
    Since:
    
    1.2.0
  - le
```
SubqueryBuilder<T> le(FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the LE predicate that can be used to apply quantors.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - le
```
SubqueryBuilder<T> le(String subqueryAlias,
                      String expression,
                      FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the LE predicate that can be used to apply quantors.
    All occurrences of subqueryAlias in expression will be replaced by the subquery. When the subquery builder and the restriction builder for the right hand side are finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    
    expression - The expression which will be used as right hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - le
```
T le(Object value)
```
    Finishes the LE predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is less or equal to the given value.
    
    Parameters:
    
    value - The value on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - leExpression
```
T leExpression(String expression)
```
    Finishes the LE predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is less or equal to the given expression.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - in
```
SubqueryInitiator<T> in()
```
    Starts a SubqueryInitiator for the right hand side of the IN predicate. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Returns:
    
    The subquery initiator for building a subquery
  - notIn
```
SubqueryInitiator<T> notIn()
```
    Like in() but the result is wrapped in a NOT predicate.
    
    Returns:
    
    The subquery initiator for building a subquery
  - in
```
SubqueryBuilder<T> in(FullQueryBuilder<?,?> criteriaBuilder)
```
    Starts a SubqueryBuilder based on the given criteria builder for the right hand side of the IN predicate. When the builder finishes, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - notIn
```
SubqueryBuilder<T> notIn(FullQueryBuilder<?,?> criteriaBuilder)
```
    Like in(FullQueryBuilder) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    criteriaBuilder - The criteria builder to base the subquery on
    
    Returns:
    
    The subquery builder for building a subquery
    
    Since:
    
    1.2.0
  - inExpressions
```
T inExpressions(String... parameterOrLiteralExpressions)
```
    Finishes the IN predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is in the parameter- or literal-expressions denoted by the given parameters.
    
    Parameters:
    
    parameterOrLiteralExpressions - The parameter- or literal-expressions on the right hand side
    
    Returns:
    
    The parent predicate container builder
    
    Since:
    
    1.1.0
  - in
```
T in(Collection<?> values)
```
    Finishes the IN predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is in the list of given values.
    
    Parameters:
    
    values - The values on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - in
```
T in(Object... values)
```
    Like in(java.util.Collection) but the values will be wrapped in a Collection.
    
    Parameters:
    
    values - The values on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - notInExpressions
```
T notInExpressions(String... parameterOrLiteralExpressions)
```
    Like inExpressions(String...) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    parameterOrLiteralExpressions - The parameter- or literal-expressions on the right hand side
    
    Returns:
    
    The parent predicate container builder
    
    Since:
    
    1.1.0
  - notIn
```
T notIn(Collection<?> values)
```
    Like in(java.util.Collection) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    values - The values on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - notIn
```
T notIn(Object... values)
```
    Like notIn(java.util.Collection) but the values will be wrapped in a Collection.
    
    Parameters:
    
    values - The values on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - isNull
```
T isNull()
```
    Finishes the IS NULL predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is null.
    
    Returns:
    
    The parent predicate container builder
  - isNotNull
```
T isNotNull()
```
    Like isNull() but the result is wrapped in a NOT predicate.
    
    Returns:
    
    The parent predicate container builder
  - isEmpty
```
T isEmpty()
```
    Finishes the IS EMPTY predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is empty.
    
    Returns:
    
    The parent predicate container builder
  - isNotEmpty
```
T isNotEmpty()
```
    Like isEmpty() but the result is wrapped in a NOT predicate.
    
    Returns:
    
    The parent predicate container builder
  - isMemberOf
```
T isMemberOf(String expression)
```
    Finishes the MEMBER OF predicate and adds it to the parent predicate container represented by the type T. The predicate checks if the left hand side is of the given expression.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - isNotMemberOf
```
T isNotMemberOf(String expression)
```
    Like isMemberOf(java.lang.String) but the result is wrapped in a NOT predicate.
    
    Parameters:
    
    expression - The expression on the right hand side
    
    Returns:
    
    The parent predicate container builder
  - like
```
LikeBuilder<T> like(boolean caseSensitive)
```
    Creates a LikeBuilder for building a like predicate.
    The predicate checks if the left hand side is like the pattern delivered by the LikeBuilder while respecting the case sensitivity according to the caseSensitive parameter.
    
    Once the LikeBuilder is finished, the predicate is added to the parent predicate container represented by the type T.
    
    Parameters:
    
    caseSensitive - If true, the comparison of the left hand side expression with the pattern respects is performed case sensitive, else it is performed case insensitive.
    
    Returns:
    
    The LikeBuilder for building the comparison pattern.
  - like
```
LikeBuilder<T> like()
```
    Like like(boolean) with caseSensitive = true.
    
    Returns:
    
    The LikeBuilder for building the comparison pattern.
  - notLike
```
LikeBuilder<T> notLike(boolean caseSensitive)
```
    Like like(boolean) but the resulting like predicate is negated.
    
    Parameters:
    
    caseSensitive - If true, the comparison of the left hand side expression with the pattern respects is performed case sensitive, else it is performed case insensitive.
    
    Returns:
    
    The LikeBuilder for building the comparison pattern.
  - notLike
```
LikeBuilder<T> notLike()
```
    Like notLike(boolean) with caseSensitive = true.
    
    Returns:
    
    The LikeBuilder for building the comparison pattern.
  - nonPortable
```
RestrictionBuilderExperimental<T> nonPortable()
```
    Switch to the non portable mode which might to be portable to other JPA providers.
    
    Returns:
    
    this restriction builder in the non portable mode

Interface RestrictionBuilder<T>

Method Summary

Method Detail

betweenExpression

between

betweenSubquery

betweenSubquery

betweenSubqueries

betweenSubquery

betweenSubquery

notBetweenExpression

notBetween

notBetweenSubquery

notBetweenSubquery

notBetweenSubqueries

notBetweenSubquery

notBetweenSubquery

eq

eq

eqSubqueries

eq

eq

eq

eqExpression

notEq

notEq

notEqSubqueries

notEq

notEq

notEq

notEqExpression

gt

gt

gtSubqueries

gt

gt

gt

gtExpression

ge

ge

geSubqueries

ge

ge

ge

geExpression

lt

lt

ltSubqueries

lt

lt

lt

ltExpression

le

le

leSubqueries

le

le

le

leExpression

in

notIn

in

notIn

inExpressions

in

in

notInExpressions

notIn

notIn

isNull

isNotNull

isEmpty

isNotEmpty

isMemberOf

isNotMemberOf

like

like

notLike

notLike

nonPortable