public interface CriteriaBuilder

Used to construct criteria queries, compound selections, expressions, predicates, orderings.

Note that Predicate is used instead of Expression<Boolean> in this API in order to work around the fact that Java generics are not compatible with varags.

Since:: 2.0

Nested Class Summary

Nested Classes

Modifier and Type

Interface

Description

static interface

CriteriaBuilder.Case<R>

Interface used to build general case expressions.

static interface

CriteriaBuilder.Coalesce<T>

Interface used to build coalesce expressions.

static interface

CriteriaBuilder.In<T>

Interface used to build in predicates.

static interface

CriteriaBuilder.SimpleCase<C,R>

Interface used to build simple case expressions.

static enum

CriteriaBuilder.Trimspec

Used to specify how strings are trimmed.
Method Summary

Modifier and Type

Method

Description

<N extends Number> Expression<N>

abs(Expression<N> x)

Create an expression that returns the absolute value of its argument.

<Y> Expression<Y>

all(Subquery<Y> subquery)

Create an all expression over the subquery results.

Predicate

and(Expression<Boolean> x, Expression<Boolean> y)

Create a conjunction of the given boolean expressions.

Predicate

and(Predicate... restrictions)

Create a conjunction of the given restriction predicates.

<Y> Expression<Y>

any(Subquery<Y> subquery)

Create an any expression over the subquery results.

CompoundSelection<Object[]>

array(Selection<?>... selections)

Create an array-valued selection item.

Order

asc(Expression<?> x)

Create an ordering by the ascending value of the expression.

<N extends Number> Expression<Double>

avg(Expression<N> x)

Create an aggregate expression applying the avg operation.

<Y extends Comparable<? super Y>> Predicate

between(Expression<? extends Y> v, Expression<? extends Y> x, Expression<? extends Y> y)

Create a predicate for testing whether the first argument is between the second and third arguments in value.

<Y extends Comparable<? super Y>> Predicate

between(Expression<? extends Y> v, Y x, Y y)

Create a predicate for testing whether the first argument is between the second and third arguments in value.

<T> CriteriaBuilder.Coalesce<T>

coalesce()

Create a coalesce expression.

<Y> Expression<Y>

coalesce(Expression<? extends Y> x, Expression<? extends Y> y)

Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.

<Y> Expression<Y>

coalesce(Expression<? extends Y> x, Y y)

Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.

Expression<String>

concat(Expression<String> x, Expression<String> y)

Create an expression for string concatenation.

Expression<String>

concat(Expression<String> x, String y)

Create an expression for string concatenation.

Expression<String>

concat(String x, Expression<String> y)

Create an expression for string concatenation.

Predicate

conjunction()

Create a conjunction (with zero conjuncts).

<Y> CompoundSelection<Y>

construct(Class<Y> resultClass, Selection<?>... selections)

Create a selection item corresponding to a constructor.

Expression<Long>

count(Expression<?> x)

Create an aggregate expression applying the count operation.

Expression<Long>

countDistinct(Expression<?> x)

Create an aggregate expression applying the count distinct operation.

<T> CriteriaDelete<T>

createCriteriaDelete(Class<T> targetEntity)

Create a CriteriaDelete query object to perform a bulk delete operation.

<T> CriteriaUpdate<T>

createCriteriaUpdate(Class<T> targetEntity)

Create a CriteriaUpdate query object to perform a bulk update operation.

CriteriaQuery<Object>

createQuery()

Create a CriteriaQuery object.

<T> CriteriaQuery<T>

createQuery(Class<T> resultClass)

Create a CriteriaQuery object with the specified result type.

CriteriaQuery<Tuple>

createTupleQuery()

Create a CriteriaQuery object that returns a tuple of objects as its result.

Expression<Date>

currentDate()

Create expression to return current date.

Expression<Time>

currentTime()

Create expression to return current time.

Expression<Timestamp>

currentTimestamp()

Create expression to return current timestamp.

Order

desc(Expression<?> x)

Create an ordering by the descending value of the expression.

<N extends Number> Expression<N>

diff(Expression<? extends N> x, Expression<? extends N> y)

Create an expression that returns the difference between its arguments.

<N extends Number> Expression<N>

diff(Expression<? extends N> x, N y)

Create an expression that returns the difference between its arguments.

<N extends Number> Expression<N>

diff(N x, Expression<? extends N> y)

Create an expression that returns the difference between its arguments.

Predicate

disjunction()

Create a disjunction (with zero disjuncts).

Predicate

equal(Expression<?> x, Expression<?> y)

Create a predicate for testing the arguments for equality.

Predicate

equal(Expression<?> x, Object y)

Create a predicate for testing the arguments for equality.

Predicate

exists(Subquery<?> subquery)

Create a predicate testing the existence of a subquery result.

<T> Expression<T>

function(String name, Class<T> type, Expression<?>... args)

Create an expression for the execution of a database function.

Predicate

ge(Expression<? extends Number> x, Expression<? extends Number> y)

Create a predicate for testing whether the first argument is greater than or equal to the second.

Predicate

ge(Expression<? extends Number> x, Number y)

Create a predicate for testing whether the first argument is greater than or equal to the second.

<Y extends Comparable<? super Y>> Predicate

greaterThan(Expression<? extends Y> x, Expression<? extends Y> y)

Create a predicate for testing whether the first argument is greater than the second.

<Y extends Comparable<? super Y>> Predicate

greaterThan(Expression<? extends Y> x, Y y)

Create a predicate for testing whether the first argument is greater than the second.

<Y extends Comparable<? super Y>> Predicate

greaterThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y)

Create a predicate for testing whether the first argument is greater than or equal to the second.

<Y extends Comparable<? super Y>> Predicate

greaterThanOrEqualTo(Expression<? extends Y> x, Y y)

Create a predicate for testing whether the first argument is greater than or equal to the second.

<X extends Comparable<? super X>> Expression<X>

greatest(Expression<X> x)

Create an aggregate expression for finding the greatest of the values (strings, dates, etc).

Predicate

gt(Expression<? extends Number> x, Expression<? extends Number> y)

Create a predicate for testing whether the first argument is greater than the second.

Predicate

gt(Expression<? extends Number> x, Number y)

Create a predicate for testing whether the first argument is greater than the second.

<T> CriteriaBuilder.In<T>

in(Expression<? extends T> expression)

Create predicate to test whether given expression is contained in a list of values.

<C extends Collection<?>> Predicate

isEmpty(Expression<C> collection)

Create a predicate that tests whether a collection is empty.

Predicate

isFalse(Expression<Boolean> x)

Create a predicate testing for a false value.

<E, C extends Collection<E>> Predicate

isMember(E elem, Expression<C> collection)

Create a predicate that tests whether an element is a member of a collection.

<E, C extends Collection<E>> Predicate

isMember(Expression<E> elem, Expression<C> collection)

Create a predicate that tests whether an element is a member of a collection.

<C extends Collection<?>> Predicate

isNotEmpty(Expression<C> collection)

Create a predicate that tests whether a collection is not empty.

<E, C extends Collection<E>> Predicate

isNotMember(E elem, Expression<C> collection)

Create a predicate that tests whether an element is not a member of a collection.

<E, C extends Collection<E>> Predicate

isNotMember(Expression<E> elem, Expression<C> collection)

Create a predicate that tests whether an element is not a member of a collection.

Predicate

isNotNull(Expression<?> x)

Create a predicate to test whether the expression is not null.

Predicate

isNull(Expression<?> x)

Create a predicate to test whether the expression is null.

Predicate

isTrue(Expression<Boolean> x)

Create a predicate testing for a true value.

<K, M extends Map<K, ?>> Expression<Set<K>>

keys(M map)

Create an expression that returns the keys of a map.

Predicate

le(Expression<? extends Number> x, Expression<? extends Number> y)

Create a predicate for testing whether the first argument is less than or equal to the second.

Predicate

le(Expression<? extends Number> x, Number y)

Create a predicate for testing whether the first argument is less than or equal to the second.

<X extends Comparable<? super X>> Expression<X>

least(Expression<X> x)

Create an aggregate expression for finding the least of the values (strings, dates, etc).

Expression<Integer>

length(Expression<String> x)

Create expression to return length of a string.

<Y extends Comparable<? super Y>> Predicate

lessThan(Expression<? extends Y> x, Expression<? extends Y> y)

Create a predicate for testing whether the first argument is less than the second.

<Y extends Comparable<? super Y>> Predicate

lessThan(Expression<? extends Y> x, Y y)

Create a predicate for testing whether the first argument is less than the second.

<Y extends Comparable<? super Y>> Predicate

lessThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y)

Create a predicate for testing whether the first argument is less than or equal to the second.

<Y extends Comparable<? super Y>> Predicate

lessThanOrEqualTo(Expression<? extends Y> x, Y y)

Create a predicate for testing whether the first argument is less than or equal to the second.

Predicate

like(Expression<String> x, Expression<String> pattern)

Create a predicate for testing whether the expression satisfies the given pattern.

Predicate

like(Expression<String> x, Expression<String> pattern, char escapeChar)

Create a predicate for testing whether the expression satisfies the given pattern.

Predicate

like(Expression<String> x, Expression<String> pattern, Expression<Character> escapeChar)

Create a predicate for testing whether the expression satisfies the given pattern.

Predicate

like(Expression<String> x, String pattern)

Create a predicate for testing whether the expression satisfies the given pattern.

Predicate

like(Expression<String> x, String pattern, char escapeChar)

Create a predicate for testing whether the expression satisfies the given pattern.

Predicate

like(Expression<String> x, String pattern, Expression<Character> escapeChar)

Create a predicate for testing whether the expression satisfies the given pattern.

<T> Expression<T>

literal(T value)

Create an expression for a literal.

Expression<Integer>

locate(Expression<String> x, Expression<String> pattern)

Create expression to locate the position of one string within another, returning position of first character if found.

Expression<Integer>

locate(Expression<String> x, Expression<String> pattern, Expression<Integer> from)

Create expression to locate the position of one string within another, returning position of first character if found.

Expression<Integer>

locate(Expression<String> x, String pattern)

Create expression to locate the position of one string within another, returning position of first character if found.

Expression<Integer>

locate(Expression<String> x, String pattern, int from)

Create expression to locate the position of one string within another, returning position of first character if found.

Expression<String>

lower(Expression<String> x)

Create expression for converting a string to lowercase.

Predicate

lt(Expression<? extends Number> x, Expression<? extends Number> y)

Create a predicate for testing whether the first argument is less than the second.

Predicate

lt(Expression<? extends Number> x, Number y)

Create a predicate for testing whether the first argument is less than the second.

<N extends Number> Expression<N>

max(Expression<N> x)

Create an aggregate expression applying the numerical max operation.

<N extends Number> Expression<N>

min(Expression<N> x)

Create an aggregate expression applying the numerical min operation.

Expression<Integer>

mod(Expression<Integer> x, Expression<Integer> y)

Create an expression that returns the modulus of its arguments.

Expression<Integer>

mod(Expression<Integer> x, Integer y)

Create an expression that returns the modulus of its arguments.

Expression<Integer>

mod(Integer x, Expression<Integer> y)

Create an expression that returns the modulus of its arguments.

<N extends Number> Expression<N>

neg(Expression<N> x)

Create an expression that returns the arithmetic negation of its argument.

Predicate

not(Expression<Boolean> restriction)

Create a negation of the given restriction.

Predicate

notEqual(Expression<?> x, Expression<?> y)

Create a predicate for testing the arguments for inequality.

Predicate

notEqual(Expression<?> x, Object y)

Create a predicate for testing the arguments for inequality.

Predicate

notLike(Expression<String> x, Expression<String> pattern)

Create a predicate for testing whether the expression does not satisfy the given pattern.

Predicate

notLike(Expression<String> x, Expression<String> pattern, char escapeChar)

Create a predicate for testing whether the expression does not satisfy the given pattern.

Predicate

notLike(Expression<String> x, Expression<String> pattern, Expression<Character> escapeChar)

Create a predicate for testing whether the expression does not satisfy the given pattern.

Predicate

notLike(Expression<String> x, String pattern)

Create a predicate for testing whether the expression does not satisfy the given pattern.

Predicate

notLike(Expression<String> x, String pattern, char escapeChar)

Create a predicate for testing whether the expression does not satisfy the given pattern.

Predicate

notLike(Expression<String> x, String pattern, Expression<Character> escapeChar)

Create a predicate for testing whether the expression does not satisfy the given pattern.

<Y> Expression<Y>

nullif(Expression<Y> x, Expression<?> y)

Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.

<Y> Expression<Y>

nullif(Expression<Y> x, Y y)

Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.

<T> Expression<T>

nullLiteral(Class<T> resultClass)

Create an expression for a null literal with the given type.

Predicate

or(Expression<Boolean> x, Expression<Boolean> y)

Create a disjunction of the given boolean expressions.

Predicate

or(Predicate... restrictions)

Create a disjunction of the given restriction predicates.

<T> ParameterExpression<T>

parameter(Class<T> paramClass)

Create a parameter expression.

<T> ParameterExpression<T>

parameter(Class<T> paramClass, String name)

Create a parameter expression with the given name.

<N extends Number> Expression<N>

prod(Expression<? extends N> x, Expression<? extends N> y)

Create an expression that returns the product of its arguments.

<N extends Number> Expression<N>

prod(Expression<? extends N> x, N y)

Create an expression that returns the product of its arguments.

<N extends Number> Expression<N>

prod(N x, Expression<? extends N> y)

Create an expression that returns the product of its arguments.

Expression<Number>

quot(Expression<? extends Number> x, Expression<? extends Number> y)

Create an expression that returns the quotient of its arguments.

Expression<Number>

quot(Expression<? extends Number> x, Number y)

Create an expression that returns the quotient of its arguments.

Expression<Number>

quot(Number x, Expression<? extends Number> y)

Create an expression that returns the quotient of its arguments.

<R> CriteriaBuilder.Case<R>

selectCase()

Create a general case expression.

<C, R> CriteriaBuilder.SimpleCase<C,R>

selectCase(Expression<? extends C> expression)

Create a simple case expression.

<C extends Collection<?>> Expression<Integer>

size(C collection)

Create an expression that tests the size of a collection.

<C extends Collection<?>> Expression<Integer>

size(Expression<C> collection)

Create an expression that tests the size of a collection.

<Y> Expression<Y>

some(Subquery<Y> subquery)

Create a some expression over the subquery results.

Expression<Double>

sqrt(Expression<? extends Number> x)

Create an expression that returns the square root of its argument.

Expression<String>

substring(Expression<String> x, int from)

Create an expression for substring extraction.

Expression<String>

substring(Expression<String> x, int from, int len)

Create an expression for substring extraction.

Expression<String>

substring(Expression<String> x, Expression<Integer> from)

Create an expression for substring extraction.

Expression<String>

substring(Expression<String> x, Expression<Integer> from, Expression<Integer> len)

Create an expression for substring extraction.

<N extends Number> Expression<N>

sum(Expression<? extends N> x, Expression<? extends N> y)

Create an expression that returns the sum of its arguments.

<N extends Number> Expression<N>

sum(Expression<? extends N> x, N y)

Create an expression that returns the sum of its arguments.

<N extends Number> Expression<N>

sum(Expression<N> x)

Create an aggregate expression applying the sum operation.

<N extends Number> Expression<N>

sum(N x, Expression<? extends N> y)

Create an expression that returns the sum of its arguments.

Expression<Double>

sumAsDouble(Expression<Float> x)

Create an aggregate expression applying the sum operation to a Float-valued expression, returning a Double result.

Expression<Long>

sumAsLong(Expression<Integer> x)

Create an aggregate expression applying the sum operation to an Integer-valued expression, returning a Long result.

Expression<BigDecimal>

toBigDecimal(Expression<? extends Number> number)

Typecast.

Expression<BigInteger>

toBigInteger(Expression<? extends Number> number)

Typecast.

Expression<Double>

toDouble(Expression<? extends Number> number)

Typecast.

Expression<Float>

toFloat(Expression<? extends Number> number)

Typecast.

Expression<Integer>

toInteger(Expression<? extends Number> number)

Typecast.

Expression<Long>

toLong(Expression<? extends Number> number)

Typecast.

Expression<String>

toString(Expression<Character> character)

Typecast.

<X, T, E extends T> CollectionJoin<X,E>

treat(CollectionJoin<X,T> join, Class<E> type)

Downcast CollectionJoin object to the specified type.

<X, T, V extends T> Join<X,V>

treat(Join<X,T> join, Class<V> type)

Downcast Join object to the specified type.

<X, T, E extends T> ListJoin<X,E>

treat(ListJoin<X,T> join, Class<E> type)

Downcast ListJoin object to the specified type.

<X, K, T, V extends T> MapJoin<X,K,V>

treat(MapJoin<X,K,T> join, Class<V> type)

Downcast MapJoin object to the specified type.

<X, T extends X> Path<T>

treat(Path<X> path, Class<T> type)

Downcast Path object to the specified type.

<X, T extends X> Root<T>

treat(Root<X> root, Class<T> type)

Downcast Root object to the specified type.

<X, T, E extends T> SetJoin<X,E>

treat(SetJoin<X,T> join, Class<E> type)

Downcast SetJoin object to the specified type.

Expression<String>

trim(char t, Expression<String> x)

Create expression to trim character from both ends of a string.

Expression<String>

trim(CriteriaBuilder.Trimspec ts, char t, Expression<String> x)

Create expression to trim character from a string.

Expression<String>

trim(CriteriaBuilder.Trimspec ts, Expression<Character> t, Expression<String> x)

Create expression to trim character from a string.

Expression<String>

trim(CriteriaBuilder.Trimspec ts, Expression<String> x)

Create expression to trim blanks from a string.

Expression<String>

trim(Expression<Character> t, Expression<String> x)

Create expression to trim character from both ends of a string.

Expression<String>

trim(Expression<String> x)

Create expression to trim blanks from both ends of a string.

CompoundSelection<Tuple>

tuple(Selection<?>... selections)

Create a tuple-valued selection item.

Expression<String>

upper(Expression<String> x)

Create expression for converting a string to uppercase.

<V, M extends Map<?, V>> Expression<Collection<V>>

values(M map)

Create an expression that returns the values of a map.

Method Details
- createQuery
  
  CriteriaQuery<Object> createQuery()
  
  Create a CriteriaQuery object.
  
  Returns:
  
  criteria query object
- createQuery
  
  <T> CriteriaQuery<T> createQuery(Class<T> resultClass)
  
  Create a CriteriaQuery object with the specified result type.
  
  Parameters:
  
  resultClass - type of the query result
  
  Returns:
  
  criteria query object
- createTupleQuery
  
  CriteriaQuery<Tuple> createTupleQuery()
  
  Create a CriteriaQuery object that returns a tuple of objects as its result.
  
  Returns:
  
  criteria query object
- createCriteriaUpdate
  
  <T> CriteriaUpdate<T> createCriteriaUpdate(Class<T> targetEntity)
  
  Create a CriteriaUpdate query object to perform a bulk update operation.
  
  Parameters:
  
  targetEntity - target type for update operation
  
  Returns:
  
  the query object
  
  Since:
  
  2.1
- createCriteriaDelete
  
  <T> CriteriaDelete<T> createCriteriaDelete(Class<T> targetEntity)
  
  Create a CriteriaDelete query object to perform a bulk delete operation.
  
  Parameters:
  
  targetEntity - target type for delete operation
  
  Returns:
  
  the query object
  
  Since:
  
  2.1
- construct
  
  <Y> CompoundSelection<Y> construct(Class<Y> resultClass, Selection<?>... selections)
  
  Create a selection item corresponding to a constructor. This method is used to specify a constructor that will be applied to the results of the query execution. If the constructor is for an entity class, the resulting entities will be in the new state after the query is executed.
  
  Parameters:
  
  resultClass - class whose instance is to be constructed
  
  selections - arguments to the constructor
  
  Returns:
  
  compound selection item
  
  Throws:
  
  IllegalArgumentException - if an argument is a tuple- or array-valued selection item
- tuple
  
  CompoundSelection<Tuple> tuple(Selection<?>... selections)
  
  Create a tuple-valued selection item.
  
  Parameters:
  
  selections - selection items
  
  Returns:
  
  tuple-valued compound selection
  
  Throws:
  
  IllegalArgumentException - if an argument is a tuple- or array-valued selection item
- array
  
  CompoundSelection<Object[]> array(Selection<?>... selections)
  
  Create an array-valued selection item.
  
  Parameters:
  
  selections - selection items
  
  Returns:
  
  array-valued compound selection
  
  Throws:
  
  IllegalArgumentException - if an argument is a tuple- or array-valued selection item
- asc
  
  Order asc(Expression<?> x)
  
  Create an ordering by the ascending value of the expression.
  
  Parameters:
  
  x - expression used to define the ordering
  
  Returns:
  
  ascending ordering corresponding to the expression
- desc
  
  Order desc(Expression<?> x)
  
  Create an ordering by the descending value of the expression.
  
  Parameters:
  
  x - expression used to define the ordering
  
  Returns:
  
  descending ordering corresponding to the expression
- avg
  
  <N extends Number> Expression<Double> avg(Expression<N> x)
  
  Create an aggregate expression applying the avg operation.
  
  Parameters:
  
  x - expression representing input value to avg operation
  
  Returns:
  
  avg expression
- sum
  
  <N extends Number> Expression<N> sum(Expression<N> x)
  
  Create an aggregate expression applying the sum operation.
  
  Parameters:
  
  x - expression representing input value to sum operation
  
  Returns:
  
  sum expression
- sumAsLong
  
  Expression<Long> sumAsLong(Expression<Integer> x)
  
  Create an aggregate expression applying the sum operation to an Integer-valued expression, returning a Long result.
  
  Parameters:
  
  x - expression representing input value to sum operation
  
  Returns:
  
  sum expression
- sumAsDouble
  
  Expression<Double> sumAsDouble(Expression<Float> x)
  
  Create an aggregate expression applying the sum operation to a Float-valued expression, returning a Double result.
  
  Parameters:
  
  x - expression representing input value to sum operation
  
  Returns:
  
  sum expression
- max
  
  <N extends Number> Expression<N> max(Expression<N> x)
  
  Create an aggregate expression applying the numerical max operation.
  
  Parameters:
  
  x - expression representing input value to max operation
  
  Returns:
  
  max expression
- min
  
  <N extends Number> Expression<N> min(Expression<N> x)
  
  Create an aggregate expression applying the numerical min operation.
  
  Parameters:
  
  x - expression representing input value to min operation
  
  Returns:
  
  min expression
- greatest
  
  <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> x)
  
  Create an aggregate expression for finding the greatest of the values (strings, dates, etc).
  
  Parameters:
  
  x - expression representing input value to greatest operation
  
  Returns:
  
  greatest expression
- least
  
  <X extends Comparable<? super X>> Expression<X> least(Expression<X> x)
  
  Create an aggregate expression for finding the least of the values (strings, dates, etc).
  
  Parameters:
  
  x - expression representing input value to least operation
  
  Returns:
  
  least expression
- count
  
  Expression<Long> count(Expression<?> x)
  
  Create an aggregate expression applying the count operation.
  
  Parameters:
  
  x - expression representing input value to count operation
  
  Returns:
  
  count expression
- countDistinct
  
  Expression<Long> countDistinct(Expression<?> x)
  
  Create an aggregate expression applying the count distinct operation.
  
  Parameters:
  
  x - expression representing input value to count distinct operation
  
  Returns:
  
  count distinct expression
- exists
  
  Predicate exists(Subquery<?> subquery)
  
  Create a predicate testing the existence of a subquery result.
  
  Parameters:
  
  subquery - subquery whose result is to be tested
  
  Returns:
  
  exists predicate
- all
  
  <Y> Expression<Y> all(Subquery<Y> subquery)
  
  Create an all expression over the subquery results.
  
  Parameters:
  
  subquery - subquery
  
  Returns:
  
  all expression
- some
  
  <Y> Expression<Y> some(Subquery<Y> subquery)
  
  Create a some expression over the subquery results. This expression is equivalent to an any expression.
  
  Parameters:
  
  subquery - subquery
  
  Returns:
  
  some expression
- any
  
  <Y> Expression<Y> any(Subquery<Y> subquery)
  
  Create an any expression over the subquery results. This expression is equivalent to a some expression.
  
  Parameters:
  
  subquery - subquery
  
  Returns:
  
  any expression
- and
  
  Predicate and(Expression<Boolean> x, Expression<Boolean> y)
  
  Create a conjunction of the given boolean expressions.
  
  Parameters:
  
  x - boolean expression
  
  y - boolean expression
  
  Returns:
  
  and predicate
- and
  
  Predicate and(Predicate... restrictions)
  
  Create a conjunction of the given restriction predicates. A conjunction of zero predicates is true.
  
  Parameters:
  
  restrictions - zero or more restriction predicates
  
  Returns:
  
  and predicate
- or
  
  Predicate or(Expression<Boolean> x, Expression<Boolean> y)
  
  Create a disjunction of the given boolean expressions.
  
  Parameters:
  
  x - boolean expression
  
  y - boolean expression
  
  Returns:
  
  or predicate
- or
  
  Predicate or(Predicate... restrictions)
  
  Create a disjunction of the given restriction predicates. A disjunction of zero predicates is false.
  
  Parameters:
  
  restrictions - zero or more restriction predicates
  
  Returns:
  
  or predicate
- not
  
  Predicate not(Expression<Boolean> restriction)
  
  Create a negation of the given restriction.
  
  Parameters:
  
  restriction - restriction expression
  
  Returns:
  
  not predicate
- conjunction
  
  Predicate conjunction()
  
  Create a conjunction (with zero conjuncts). A conjunction with zero conjuncts is true.
  
  Returns:
  
  and predicate
- disjunction
  
  Predicate disjunction()
  
  Create a disjunction (with zero disjuncts). A disjunction with zero disjuncts is false.
  
  Returns:
  
  or predicate
- isTrue
  
  Predicate isTrue(Expression<Boolean> x)
  
  Create a predicate testing for a true value.
  
  Parameters:
  
  x - expression to be tested
  
  Returns:
  
  predicate
- isFalse
  
  Predicate isFalse(Expression<Boolean> x)
  
  Create a predicate testing for a false value.
  
  Parameters:
  
  x - expression to be tested
  
  Returns:
  
  predicate
- isNull
  
  Predicate isNull(Expression<?> x)
  
  Create a predicate to test whether the expression is null.
  
  Parameters:
  
  x - expression
  
  Returns:
  
  is-null predicate
- isNotNull
  
  Predicate isNotNull(Expression<?> x)
  
  Create a predicate to test whether the expression is not null.
  
  Parameters:
  
  x - expression
  
  Returns:
  
  is-not-null predicate
- equal
  
  Predicate equal(Expression<?> x, Expression<?> y)
  
  Create a predicate for testing the arguments for equality.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  equality predicate
- equal
  
  Predicate equal(Expression<?> x, Object y)
  
  Create a predicate for testing the arguments for equality.
  
  Parameters:
  
  x - expression
  
  y - object
  
  Returns:
  
  equality predicate
- notEqual
  
  Predicate notEqual(Expression<?> x, Expression<?> y)
  
  Create a predicate for testing the arguments for inequality.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  inequality predicate
- notEqual
  
  Predicate notEqual(Expression<?> x, Object y)
  
  Create a predicate for testing the arguments for inequality.
  
  Parameters:
  
  x - expression
  
  y - object
  
  Returns:
  
  inequality predicate
- greaterThan
  
  <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x, Expression<? extends Y> y)
  
  Create a predicate for testing whether the first argument is greater than the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  greater-than predicate
- greaterThan
  
  <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x, Y y)
  
  Create a predicate for testing whether the first argument is greater than the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  greater-than predicate
- greaterThanOrEqualTo
  
  <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y)
  
  Create a predicate for testing whether the first argument is greater than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  greater-than-or-equal predicate
- greaterThanOrEqualTo
  
  <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> x, Y y)
  
  Create a predicate for testing whether the first argument is greater than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  greater-than-or-equal predicate
- lessThan
  
  <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> x, Expression<? extends Y> y)
  
  Create a predicate for testing whether the first argument is less than the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  less-than predicate
- lessThan
  
  <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> x, Y y)
  
  Create a predicate for testing whether the first argument is less than the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  less-than predicate
- lessThanOrEqualTo
  
  <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y)
  
  Create a predicate for testing whether the first argument is less than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  less-than-or-equal predicate
- lessThanOrEqualTo
  
  <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> x, Y y)
  
  Create a predicate for testing whether the first argument is less than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  less-than-or-equal predicate
- between
  
  <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> v, Expression<? extends Y> x, Expression<? extends Y> y)
  
  Create a predicate for testing whether the first argument is between the second and third arguments in value.
  
  Parameters:
  
  v - expression
  
  x - expression
  
  y - expression
  
  Returns:
  
  between predicate
- between
  
  <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> v, Y x, Y y)
  
  Create a predicate for testing whether the first argument is between the second and third arguments in value.
  
  Parameters:
  
  v - expression
  
  x - value
  
  y - value
  
  Returns:
  
  between predicate
- gt
  
  Predicate gt(Expression<? extends Number> x, Expression<? extends Number> y)
  
  Create a predicate for testing whether the first argument is greater than the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  greater-than predicate
- gt
  
  Predicate gt(Expression<? extends Number> x, Number y)
  
  Create a predicate for testing whether the first argument is greater than the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  greater-than predicate
- ge
  
  Predicate ge(Expression<? extends Number> x, Expression<? extends Number> y)
  
  Create a predicate for testing whether the first argument is greater than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  greater-than-or-equal predicate
- ge
  
  Predicate ge(Expression<? extends Number> x, Number y)
  
  Create a predicate for testing whether the first argument is greater than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  greater-than-or-equal predicate
- lt
  
  Predicate lt(Expression<? extends Number> x, Expression<? extends Number> y)
  
  Create a predicate for testing whether the first argument is less than the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  less-than predicate
- lt
  
  Predicate lt(Expression<? extends Number> x, Number y)
  
  Create a predicate for testing whether the first argument is less than the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  less-than predicate
- le
  
  Predicate le(Expression<? extends Number> x, Expression<? extends Number> y)
  
  Create a predicate for testing whether the first argument is less than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  less-than-or-equal predicate
- le
  
  Predicate le(Expression<? extends Number> x, Number y)
  
  Create a predicate for testing whether the first argument is less than or equal to the second.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  less-than-or-equal predicate
- neg
  
  <N extends Number> Expression<N> neg(Expression<N> x)
  
  Create an expression that returns the arithmetic negation of its argument.
  
  Parameters:
  
  x - expression
  
  Returns:
  
  arithmetic negation
- abs
  
  <N extends Number> Expression<N> abs(Expression<N> x)
  
  Create an expression that returns the absolute value of its argument.
  
  Parameters:
  
  x - expression
  
  Returns:
  
  absolute value
- sum
  
  <N extends Number> Expression<N> sum(Expression<? extends N> x, Expression<? extends N> y)
  
  Create an expression that returns the sum of its arguments.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  sum
- sum
  
  <N extends Number> Expression<N> sum(Expression<? extends N> x, N y)
  
  Create an expression that returns the sum of its arguments.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  sum
- sum
  
  <N extends Number> Expression<N> sum(N x, Expression<? extends N> y)
  
  Create an expression that returns the sum of its arguments.
  
  Parameters:
  
  x - value
  
  y - expression
  
  Returns:
  
  sum
- prod
  
  <N extends Number> Expression<N> prod(Expression<? extends N> x, Expression<? extends N> y)
  
  Create an expression that returns the product of its arguments.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  product
- prod
  
  <N extends Number> Expression<N> prod(Expression<? extends N> x, N y)
  
  Create an expression that returns the product of its arguments.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  product
- prod
  
  <N extends Number> Expression<N> prod(N x, Expression<? extends N> y)
  
  Create an expression that returns the product of its arguments.
  
  Parameters:
  
  x - value
  
  y - expression
  
  Returns:
  
  product
- diff
  
  <N extends Number> Expression<N> diff(Expression<? extends N> x, Expression<? extends N> y)
  
  Create an expression that returns the difference between its arguments.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  difference
- diff
  
  <N extends Number> Expression<N> diff(Expression<? extends N> x, N y)
  
  Create an expression that returns the difference between its arguments.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  difference
- diff
  
  <N extends Number> Expression<N> diff(N x, Expression<? extends N> y)
  
  Create an expression that returns the difference between its arguments.
  
  Parameters:
  
  x - value
  
  y - expression
  
  Returns:
  
  difference
- quot
  
  Expression<Number> quot(Expression<? extends Number> x, Expression<? extends Number> y)
  
  Create an expression that returns the quotient of its arguments.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  quotient
- quot
  
  Expression<Number> quot(Expression<? extends Number> x, Number y)
  
  Create an expression that returns the quotient of its arguments.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  quotient
- quot
  
  Expression<Number> quot(Number x, Expression<? extends Number> y)
  
  Create an expression that returns the quotient of its arguments.
  
  Parameters:
  
  x - value
  
  y - expression
  
  Returns:
  
  quotient
- mod
  
  Expression<Integer> mod(Expression<Integer> x, Expression<Integer> y)
  
  Create an expression that returns the modulus of its arguments.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  modulus
- mod
  
  Expression<Integer> mod(Expression<Integer> x, Integer y)
  
  Create an expression that returns the modulus of its arguments.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  modulus
- mod
  
  Expression<Integer> mod(Integer x, Expression<Integer> y)
  
  Create an expression that returns the modulus of its arguments.
  
  Parameters:
  
  x - value
  
  y - expression
  
  Returns:
  
  modulus
- sqrt
  
  Expression<Double> sqrt(Expression<? extends Number> x)
  
  Create an expression that returns the square root of its argument.
  
  Parameters:
  
  x - expression
  
  Returns:
  
  square root
- toLong
  
  Expression<Long> toLong(Expression<? extends Number> number)
  
  Typecast. Returns same expression object.
  
  Parameters:
  
  number - numeric expression
  
  Returns:
  
  Expression<Long>
- toInteger
  
  Expression<Integer> toInteger(Expression<? extends Number> number)
  
  Typecast. Returns same expression object.
  
  Parameters:
  
  number - numeric expression
  
  Returns:
  
  Expression<Integer>
- toFloat
  
  Expression<Float> toFloat(Expression<? extends Number> number)
  
  Typecast. Returns same expression object.
  
  Parameters:
  
  number - numeric expression
  
  Returns:
  
  Expression<Float>
- toDouble
  
  Expression<Double> toDouble(Expression<? extends Number> number)
  
  Typecast. Returns same expression object.
  
  Parameters:
  
  number - numeric expression
  
  Returns:
  
  Expression<Double>
- toBigDecimal
  
  Expression<BigDecimal> toBigDecimal(Expression<? extends Number> number)
  
  Typecast. Returns same expression object.
  
  Parameters:
  
  number - numeric expression
  
  Returns:
  
  Expression<BigDecimal>
- toBigInteger
  
  Expression<BigInteger> toBigInteger(Expression<? extends Number> number)
  
  Typecast. Returns same expression object.
  
  Parameters:
  
  number - numeric expression
  
  Returns:
  
  Expression<BigInteger>
- toString
  
  Expression<String> toString(Expression<Character> character)
  
  Typecast. Returns same expression object.
  
  Parameters:
  
  character - expression
  
  Returns:
  
  Expression<String>
- literal
  
  <T> Expression<T> literal(T value)
  
  Create an expression for a literal.
  
  Parameters:
  
  value - value represented by the expression
  
  Returns:
  
  expression literal
  
  Throws:
  
  IllegalArgumentException - if value is null
- nullLiteral
  
  <T> Expression<T> nullLiteral(Class<T> resultClass)
  
  Create an expression for a null literal with the given type.
  
  Parameters:
  
  resultClass - type of the null literal
  
  Returns:
  
  null expression literal
- parameter
  
  <T> ParameterExpression<T> parameter(Class<T> paramClass)
  
  Create a parameter expression.
  
  Parameters:
  
  paramClass - parameter class
  
  Returns:
  
  parameter expression
- parameter
  
  <T> ParameterExpression<T> parameter(Class<T> paramClass, String name)
  
  Create a parameter expression with the given name.
  
  Parameters:
  
  paramClass - parameter class
  
  name - name that can be used to refer to the parameter
  
  Returns:
  
  parameter expression
- isEmpty
  
  <C extends Collection<?>> Predicate isEmpty(Expression<C> collection)
  
  Create a predicate that tests whether a collection is empty.
  
  Parameters:
  
  collection - expression
  
  Returns:
  
  is-empty predicate
- isNotEmpty
  
  <C extends Collection<?>> Predicate isNotEmpty(Expression<C> collection)
  
  Create a predicate that tests whether a collection is not empty.
  
  Parameters:
  
  collection - expression
  
  Returns:
  
  is-not-empty predicate
- size
  
  <C extends Collection<?>> Expression<Integer> size(Expression<C> collection)
  
  Create an expression that tests the size of a collection.
  
  Parameters:
  
  collection - expression
  
  Returns:
  
  size expression
- size
  
  <C extends Collection<?>> Expression<Integer> size(C collection)
  
  Create an expression that tests the size of a collection.
  
  Parameters:
  
  collection - collection
  
  Returns:
  
  size expression
- isMember
  
  <E, C extends Collection<E>> Predicate isMember(Expression<E> elem, Expression<C> collection)
  
  Create a predicate that tests whether an element is a member of a collection. If the collection is empty, the predicate will be false.
  
  Parameters:
  
  elem - element expression
  
  collection - expression
  
  Returns:
  
  is-member predicate
- isMember
  
  <E, C extends Collection<E>> Predicate isMember(E elem, Expression<C> collection)
  
  Create a predicate that tests whether an element is a member of a collection. If the collection is empty, the predicate will be false.
  
  Parameters:
  
  elem - element
  
  collection - expression
  
  Returns:
  
  is-member predicate
- isNotMember
  
  <E, C extends Collection<E>> Predicate isNotMember(Expression<E> elem, Expression<C> collection)
  
  Create a predicate that tests whether an element is not a member of a collection. If the collection is empty, the predicate will be true.
  
  Parameters:
  
  elem - element expression
  
  collection - expression
  
  Returns:
  
  is-not-member predicate
- isNotMember
  
  <E, C extends Collection<E>> Predicate isNotMember(E elem, Expression<C> collection)
  
  Create a predicate that tests whether an element is not a member of a collection. If the collection is empty, the predicate will be true.
  
  Parameters:
  
  elem - element
  
  collection - expression
  
  Returns:
  
  is-not-member predicate
- values
  
  <V, M extends Map<?, V>> Expression<Collection<V>> values(M map)
  
  Create an expression that returns the values of a map.
  
  Parameters:
  
  map - map
  
  Returns:
  
  collection expression
- keys
  
  <K, M extends Map<K, ?>> Expression<Set<K>> keys(M map)
  
  Create an expression that returns the keys of a map.
  
  Parameters:
  
  map - map
  
  Returns:
  
  set expression
- like
  
  Predicate like(Expression<String> x, Expression<String> pattern)
  
  Create a predicate for testing whether the expression satisfies the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string expression
  
  Returns:
  
  like predicate
- like
  
  Predicate like(Expression<String> x, String pattern)
  
  Create a predicate for testing whether the expression satisfies the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string
  
  Returns:
  
  like predicate
- like
  
  Predicate like(Expression<String> x, Expression<String> pattern, Expression<Character> escapeChar)
  
  Create a predicate for testing whether the expression satisfies the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string expression
  
  escapeChar - escape character expression
  
  Returns:
  
  like predicate
- like
  
  Predicate like(Expression<String> x, Expression<String> pattern, char escapeChar)
  
  Create a predicate for testing whether the expression satisfies the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string expression
  
  escapeChar - escape character
  
  Returns:
  
  like predicate
- like
  
  Predicate like(Expression<String> x, String pattern, Expression<Character> escapeChar)
  
  Create a predicate for testing whether the expression satisfies the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string
  
  escapeChar - escape character expression
  
  Returns:
  
  like predicate
- like
  
  Predicate like(Expression<String> x, String pattern, char escapeChar)
  
  Create a predicate for testing whether the expression satisfies the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string
  
  escapeChar - escape character
  
  Returns:
  
  like predicate
- notLike
  
  Predicate notLike(Expression<String> x, Expression<String> pattern)
  
  Create a predicate for testing whether the expression does not satisfy the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string expression
  
  Returns:
  
  not-like predicate
- notLike
  
  Predicate notLike(Expression<String> x, String pattern)
  
  Create a predicate for testing whether the expression does not satisfy the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string
  
  Returns:
  
  not-like predicate
- notLike
  
  Predicate notLike(Expression<String> x, Expression<String> pattern, Expression<Character> escapeChar)
  
  Create a predicate for testing whether the expression does not satisfy the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string expression
  
  escapeChar - escape character expression
  
  Returns:
  
  not-like predicate
- notLike
  
  Predicate notLike(Expression<String> x, Expression<String> pattern, char escapeChar)
  
  Create a predicate for testing whether the expression does not satisfy the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string expression
  
  escapeChar - escape character
  
  Returns:
  
  not-like predicate
- notLike
  
  Predicate notLike(Expression<String> x, String pattern, Expression<Character> escapeChar)
  
  Create a predicate for testing whether the expression does not satisfy the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string
  
  escapeChar - escape character expression
  
  Returns:
  
  not-like predicate
- notLike
  
  Predicate notLike(Expression<String> x, String pattern, char escapeChar)
  
  Create a predicate for testing whether the expression does not satisfy the given pattern.
  
  Parameters:
  
  x - string expression
  
  pattern - string
  
  escapeChar - escape character
  
  Returns:
  
  not-like predicate
- concat
  
  Expression<String> concat(Expression<String> x, Expression<String> y)
  
  Create an expression for string concatenation.
  
  Parameters:
  
  x - string expression
  
  y - string expression
  
  Returns:
  
  expression corresponding to concatenation
- concat
  
  Expression<String> concat(Expression<String> x, String y)
  
  Create an expression for string concatenation.
  
  Parameters:
  
  x - string expression
  
  y - string
  
  Returns:
  
  expression corresponding to concatenation
- concat
  
  Expression<String> concat(String x, Expression<String> y)
  
  Create an expression for string concatenation.
  
  Parameters:
  
  x - string
  
  y - string expression
  
  Returns:
  
  expression corresponding to concatenation
- substring
  
  Expression<String> substring(Expression<String> x, Expression<Integer> from)
  
  Create an expression for substring extraction. Extracts a substring starting at the specified position through to end of the string. First position is 1.
  
  Parameters:
  
  x - string expression
  
  from - start position expression
  
  Returns:
  
  expression corresponding to substring extraction
- substring
  
  Expression<String> substring(Expression<String> x, int from)
  
  Create an expression for substring extraction. Extracts a substring starting at the specified position through to end of the string. First position is 1.
  
  Parameters:
  
  x - string expression
  
  from - start position
  
  Returns:
  
  expression corresponding to substring extraction
- substring
  
  Expression<String> substring(Expression<String> x, Expression<Integer> from, Expression<Integer> len)
  
  Create an expression for substring extraction. Extracts a substring of given length starting at the specified position. First position is 1.
  
  Parameters:
  
  x - string expression
  
  from - start position expression
  
  len - length expression
  
  Returns:
  
  expression corresponding to substring extraction
- substring
  
  Expression<String> substring(Expression<String> x, int from, int len)
  
  Create an expression for substring extraction. Extracts a substring of given length starting at the specified position. First position is 1.
  
  Parameters:
  
  x - string expression
  
  from - start position
  
  len - length
  
  Returns:
  
  expression corresponding to substring extraction
- trim
  
  Expression<String> trim(Expression<String> x)
  
  Create expression to trim blanks from both ends of a string.
  
  Parameters:
  
  x - expression for string to trim
  
  Returns:
  
  trim expression
- trim
  
  Expression<String> trim(CriteriaBuilder.Trimspec ts, Expression<String> x)
  
  Create expression to trim blanks from a string.
  
  Parameters:
  
  ts - trim specification
  
  x - expression for string to trim
  
  Returns:
  
  trim expression
- trim
  
  Expression<String> trim(Expression<Character> t, Expression<String> x)
  
  Create expression to trim character from both ends of a string.
  
  Parameters:
  
  t - expression for character to be trimmed
  
  x - expression for string to trim
  
  Returns:
  
  trim expression
- trim
  
  Expression<String> trim(CriteriaBuilder.Trimspec ts, Expression<Character> t, Expression<String> x)
  
  Create expression to trim character from a string.
  
  Parameters:
  
  ts - trim specification
  
  t - expression for character to be trimmed
  
  x - expression for string to trim
  
  Returns:
  
  trim expression
- trim
  
  Expression<String> trim(char t, Expression<String> x)
  
  Create expression to trim character from both ends of a string.
  
  Parameters:
  
  t - character to be trimmed
  
  x - expression for string to trim
  
  Returns:
  
  trim expression
- trim
  
  Expression<String> trim(CriteriaBuilder.Trimspec ts, char t, Expression<String> x)
  
  Create expression to trim character from a string.
  
  Parameters:
  
  ts - trim specification
  
  t - character to be trimmed
  
  x - expression for string to trim
  
  Returns:
  
  trim expression
- lower
  
  Expression<String> lower(Expression<String> x)
  
  Create expression for converting a string to lowercase.
  
  Parameters:
  
  x - string expression
  
  Returns:
  
  expression to convert to lowercase
- upper
  
  Expression<String> upper(Expression<String> x)
  
  Create expression for converting a string to uppercase.
  
  Parameters:
  
  x - string expression
  
  Returns:
  
  expression to convert to uppercase
- length
  
  Expression<Integer> length(Expression<String> x)
  
  Create expression to return length of a string.
  
  Parameters:
  
  x - string expression
  
  Returns:
  
  length expression
- locate
  
  Expression<Integer> locate(Expression<String> x, Expression<String> pattern)
  
  Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
  
  Parameters:
  
  x - expression for string to be searched
  
  pattern - expression for string to be located
  
  Returns:
  
  expression corresponding to position
- locate
  
  Expression<Integer> locate(Expression<String> x, String pattern)
  
  Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
  
  Parameters:
  
  x - expression for string to be searched
  
  pattern - string to be located
  
  Returns:
  
  expression corresponding to position
- locate
  
  Expression<Integer> locate(Expression<String> x, Expression<String> pattern, Expression<Integer> from)
  
  Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
  
  Parameters:
  
  x - expression for string to be searched
  
  pattern - expression for string to be located
  
  from - expression for position at which to start search
  
  Returns:
  
  expression corresponding to position
- locate
  
  Expression<Integer> locate(Expression<String> x, String pattern, int from)
  
  Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
  
  Parameters:
  
  x - expression for string to be searched
  
  pattern - string to be located
  
  from - position at which to start search
  
  Returns:
  
  expression corresponding to position
- currentDate
  
  Expression<Date> currentDate()
  
  Create expression to return current date.
  
  Returns:
  
  expression for current date
- currentTimestamp
  
  Expression<Timestamp> currentTimestamp()
  
  Create expression to return current timestamp.
  
  Returns:
  
  expression for current timestamp
- currentTime
  
  Expression<Time> currentTime()
  
  Create expression to return current time.
  
  Returns:
  
  expression for current time
- in
  
  <T> CriteriaBuilder.In<T> in(Expression<? extends T> expression)
  
  Create predicate to test whether given expression is contained in a list of values.
  
  Parameters:
  
  expression - to be tested against list of values
  
  Returns:
  
  in predicate
- coalesce
  
  <Y> Expression<Y> coalesce(Expression<? extends Y> x, Expression<? extends Y> y)
  
  Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  coalesce expression
- coalesce
  
  <Y> Expression<Y> coalesce(Expression<? extends Y> x, Y y)
  
  Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  coalesce expression
- nullif
  
  <Y> Expression<Y> nullif(Expression<Y> x, Expression<?> y)
  
  Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.
  
  Parameters:
  
  x - expression
  
  y - expression
  
  Returns:
  
  nullif expression
- nullif
  
  <Y> Expression<Y> nullif(Expression<Y> x, Y y)
  
  Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.
  
  Parameters:
  
  x - expression
  
  y - value
  
  Returns:
  
  nullif expression
- coalesce
  
  <T> CriteriaBuilder.Coalesce<T> coalesce()
  
  Create a coalesce expression.
  
  Returns:
  
  coalesce expression
- selectCase
  
  <C, R> CriteriaBuilder.SimpleCase<C,R> selectCase(Expression<? extends C> expression)
  
  Create a simple case expression.
  
  Parameters:
  
  expression - to be tested against the case conditions
  
  Returns:
  
  simple case expression
- selectCase
  
  <R> CriteriaBuilder.Case<R> selectCase()
  
  Create a general case expression.
  
  Returns:
  
  general case expression
- function
  
  <T> Expression<T> function(String name, Class<T> type, Expression<?>... args)
  
  Create an expression for the execution of a database function.
  
  Parameters:
  
  name - function name
  
  type - expected result type
  
  args - function arguments
  
  Returns:
  
  expression
- treat
  
  <X, T, V extends T> Join<X,V> treat(Join<X,T> join, Class<V> type)
  
  Downcast Join object to the specified type.
  
  Parameters:
  
  join - Join object
  
  type - type to be downcast to
  
  Returns:
  
  Join object of the specified type
  
  Since:
  
  2.1
- treat
  
  <X, T, E extends T> CollectionJoin<X,E> treat(CollectionJoin<X,T> join, Class<E> type)
  
  Downcast CollectionJoin object to the specified type.
  
  Parameters:
  
  join - CollectionJoin object
  
  type - type to be downcast to
  
  Returns:
  
  CollectionJoin object of the specified type
  
  Since:
  
  2.1
- treat
  
  <X, T, E extends T> SetJoin<X,E> treat(SetJoin<X,T> join, Class<E> type)
  
  Downcast SetJoin object to the specified type.
  
  Parameters:
  
  join - SetJoin object
  
  type - type to be downcast to
  
  Returns:
  
  SetJoin object of the specified type
  
  Since:
  
  2.1
- treat
  
  <X, T, E extends T> ListJoin<X,E> treat(ListJoin<X,T> join, Class<E> type)
  
  Downcast ListJoin object to the specified type.
  
  Parameters:
  
  join - ListJoin object
  
  type - type to be downcast to
  
  Returns:
  
  ListJoin object of the specified type
  
  Since:
  
  2.1
- treat
  
  <X, K, T, V extends T> MapJoin<X,K,V> treat(MapJoin<X,K,T> join, Class<V> type)
  
  Downcast MapJoin object to the specified type.
  
  Parameters:
  
  join - MapJoin object
  
  type - type to be downcast to
  
  Returns:
  
  MapJoin object of the specified type
  
  Since:
  
  2.1
- treat
  
  <X, T extends X> Path<T> treat(Path<X> path, Class<T> type)
  
  Downcast Path object to the specified type.
  
  Parameters:
  
  path - path
  
  type - type to be downcast to
  
  Returns:
  
  Path object of the specified type
  
  Since:
  
  2.1
- treat
  
  <X, T extends X> Root<T> treat(Root<X> root, Class<T> type)
  
  Downcast Root object to the specified type.
  
  Parameters:
  
  root - root
  
  type - type to be downcast to
  
  Returns:
  
  Root object of the specified type
  
  Since:
  
  2.1

Interface CriteriaBuilder

Nested Class Summary

Method Summary

Method Details

createQuery

createQuery

createTupleQuery

createCriteriaUpdate

createCriteriaDelete

construct

tuple

array

asc

desc

avg

sum

sumAsLong

sumAsDouble

max

min

greatest

least

count

countDistinct

exists

all

some

any

and

and

or

or

not

conjunction

disjunction

isTrue

isFalse

isNull

isNotNull

equal

equal

notEqual

notEqual

greaterThan

greaterThan

greaterThanOrEqualTo

greaterThanOrEqualTo

lessThan

lessThan

lessThanOrEqualTo

lessThanOrEqualTo

between

between

gt

gt

ge

ge

lt

lt

le

le

neg

abs

sum

sum

sum

prod

prod

prod

diff

diff

diff

quot

quot

quot

mod

mod

mod

sqrt

toLong