javax.persistence.criteria
Interface CriteriaBuilder

public interface CriteriaBuilder

Used to construct criteria queries, compound selections, expressions, predicates, orderings. Note that Predicate is used instead of Expression in this API in order to work around the fact that Java generics are not compatible with varags.

Since:

JPA 2.0 version.

Author:

Florent Benoit

See Also:

JPA 2.0 specification

Nested Class Summary

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 class	CriteriaBuilder.Trimspec

Method Summary

<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.
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, 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.
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.
<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.
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 Detail

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

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 -

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 -

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 -

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

toInteger

Expression<Integer> toInteger(Expression<? extends Number> number)

Typecast. Returns same expression object.

Parameters:

number - numeric expression

Returns:

Expression

toFloat

Expression<Float> toFloat(Expression<? extends Number> number)

Typecast. Returns same expression object.

Parameters:

number - numeric expression

Returns:

Expression

toDouble

Expression<Double> toDouble(Expression<? extends Number> number)

Typecast. Returns same expression object.

Parameters:

number - numeric expression

Returns:

Expression

toBigDecimal

Expression<BigDecimal> toBigDecimal(Expression<? extends Number> number)

Typecast. Returns same expression object.

Parameters:

number - numeric expression

Returns:

Expression

toBigInteger

Expression<BigInteger> toBigInteger(Expression<? extends Number> number)

Typecast. Returns same expression object.

Parameters:

number - numeric expression

Returns:

Expression

toString

Expression<String> toString(Expression<Character> character)

Typecast. Returns same expression object.

Parameters:

character - expression

Returns:

Expression

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