## org.hibernate.ejb.criteria
Class CriteriaBuilderImpl

    java.lang.Object
      org.hibernate.ejb.criteria.CriteriaBuilderImpl

All Implemented Interfaces:
  Serializable, CriteriaBuilder

    public class CriteriaBuilderImpl

extends Object
implements CriteriaBuilder, Serializable

Hibernate implementation of the JPA `CriteriaBuilder` contract.

See Also:
  Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface javax.persistence.criteria.CriteriaBuilder
`CriteriaBuilder.Case<R>, CriteriaBuilder.Coalesce<T>, CriteriaBuilder.In<T>, CriteriaBuilder.SimpleCase<C,R>, CriteriaBuilder.Trimspec`

Constructor Summary
`CriteriaBuilderImpl(EntityManagerFactoryImpl entityManagerFactory)`

Method Summary

`

`<N extends Number> Expression<N>`

`

`abs(Expression<N> expression)`

`

`<Y> Expression<Y>`

`

`all(Subquery<Y> subquery)`

`Predicate` `and(Expression<Boolean> x, Expression<Boolean> y)`
`Predicate` `and(Predicate... restrictions)`

`

`<Y> Expression<Y>`

`

`any(Subquery<Y> subquery)`

`

`<Y> CompoundSelection<Y>`

`

`array(Class<Y> type, List<Selection<?>> selections)`
Version of `array(Selection[])` taking a list of selections, as well as the type of array.

`CompoundSelection<Object[]>` `array(List<Selection<?>> selections)` Version of `array(Selection[])` taking a list of selections.
`CompoundSelection<Object[]>` `array(Selection<?>... selections)`
`Order` `asc(Expression<?> x)`

`

`<N extends Number> Expression<Double>`

`

`avg(Expression<N> x)`

`

`<Y extends Comparable<? super Y>> Predicate`

`

`between(Expression<? extends Y> expression, Expression<? extends Y> lowerBound, Expression<? extends Y> upperBound)`

`

`<Y extends Comparable<? super Y>> Predicate`

`

`between(Expression<? extends Y> expression, Y lowerBound, Y upperBound)`

`

`<T> CriteriaBuilder.Coalesce<T>`

`

`coalesce()`

`

`<T> CriteriaBuilder.Coalesce<T>`

`

`coalesce(Class<T> type)`

`

`<Y> Expression<Y>`

`

`coalesce(Class<Y> type, Expression<? extends Y> exp1, Expression<? extends Y> exp2)`

`

`<Y> Expression<Y>`

`

`coalesce(Class<Y> type, Expression<? extends Y> exp1, Y exp2)`

`

`<Y> Expression<Y>`

`

`coalesce(Expression<? extends Y> exp1, Expression<? extends Y> exp2)`

`

`<Y> Expression<Y>`

`

`coalesce(Expression<? extends Y> exp1, Y exp2)`

`Expression<String>` `concat(Expression<String> string1, Expression<String> string2)`
`Expression<String>` `concat(Expression<String> string1, String string2)`
`Expression<String>` `concat(String string1, Expression<String> string2)`
`Predicate` `conjunction()`

`

`<Y> CompoundSelection<Y>`

`

`construct(Class<Y> result, List<Selection<?>> selections)`
Version of `construct(Class,Selection[])` taking the to-be-constructed type as well as a list of selections.

`

`<Y> CompoundSelection<Y>`

`

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

`Expression<Long>` `count(Expression<?> x)`
`Expression<Long>` `countDistinct(Expression<?> x)`
`CriteriaQuery<Object>` `createQuery()`

`

`<T> CriteriaQuery<T>`

`

`createQuery(Class<T> resultClass)`

`CriteriaQuery<Tuple>` `createTupleQuery()`
`Expression<Date>` `currentDate()`
`Expression<Time>` `currentTime()`
`Expression<Timestamp>` `currentTimestamp()`
`Order` `desc(Expression<?> x)`

`

`<N extends Number> Expression<N>`

`

`diff(Expression<? extends N> expression1, Expression<? extends N> expression2)`

`

`<N extends Number> Expression<N>`

`

`diff(Expression<? extends N> expression, N n)`

`

`<N extends Number> Expression<N>`

`

`diff(N n, Expression<? extends N> expression)`

`Predicate` `disjunction()`
`Predicate` `equal(Expression<?> x, Expression<?> y)`
`Predicate` `equal(Expression<?> x, Object y)`
`Predicate` `exists(Subquery<?> subquery)`

`

`<T> Expression<T>`

`

`function(String name, Class<T> returnType)`
Create a reference to a function taking no params.

`

`<T> Expression<T>`

`

`function(String name, Class<T> returnType, Expression<?>... arguments)`

`Predicate` `ge(Expression<? extends Number> x, Expression<? extends Number> y)`
`Predicate` `ge(Expression<? extends Number> x, Number y)`
`EntityManagerFactoryImpl` `getEntityManagerFactory()` Provides protected access to the underlying `EntityManagerFactoryImpl`.

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`

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

`

`greatest(Expression<X> x)`

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

`

`<T> CriteriaBuilder.In<T>`

`

`in(Expression<? extends T> expression)`

`

`<T> CriteriaBuilder.In<T>`

`

`in(Expression<? extends T> expression, Collection<T> values)`

`

`<T> CriteriaBuilder.In<T>`

`

`in(Expression<? extends T> expression, Expression<? extends T>... values)`

`

`<T> CriteriaBuilder.In<T>`

`

`in(Expression<? extends T> expression, T... values)`

`

`<C extends Collection<?>> Predicate`

`

`isEmpty(Expression<C> collectionExpression)`

`Predicate` `isFalse(Expression<Boolean> expression)`

`

`<E,C extends Collection<E>> Predicate`

`

`isMember(E e, Expression<C> collectionExpression)`

`

`<E,C extends Collection<E>> Predicate`

`

`isMember(Expression<E> elementExpression, Expression<C> collectionExpression)`

`

`<C extends Collection<?>> Predicate`

`

`isNotEmpty(Expression<C> collectionExpression)`

`

`<E,C extends Collection<E>> Predicate`

`

`isNotMember(E e, Expression<C> cExpression)`

`

`<E,C extends Collection<E>> Predicate`

`

`isNotMember(Expression<E> eExpression, Expression<C> cExpression)`

`Predicate` `isNotNull(Expression<?> x)`
`Predicate` `isNull(Expression<?> x)` s
`Predicate` `isTrue(Expression<Boolean> expression)`

`

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

`

`keys(M map)`

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

`

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

`

`least(Expression<X> x)`

`Expression<Integer>` `length(Expression<String> value)`

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`

`<Y extends Comparable<? super Y>> Predicate`

`

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

`Predicate` `like(Expression<String> matchExpression, Expression<String> pattern)`
`Predicate` `like(Expression<String> matchExpression, Expression<String> pattern, char escapeCharacter)`
`Predicate` `like(Expression<String> matchExpression, Expression<String> pattern, Expression<Character> escapeCharacter)`
`Predicate` `like(Expression<String> matchExpression, String pattern)`
`Predicate` `like(Expression<String> matchExpression, String pattern, char escapeCharacter)`
`Predicate` `like(Expression<String> matchExpression, String pattern, Expression<Character> escapeCharacter)`

`

`<T> Expression<T>`

`

`literal(T value)`

`Expression<Integer>` `locate(Expression<String> string, Expression<String> pattern)`
`Expression<Integer>` `locate(Expression<String> string, Expression<String> pattern, Expression<Integer> start)`
`Expression<Integer>` `locate(Expression<String> string, String pattern)`
`Expression<Integer>` `locate(Expression<String> string, String pattern, int start)`
`Expression<String>` `lower(Expression<String> value)`
`Predicate` `lt(Expression<? extends Number> x, Expression<? extends Number> y)`
`Predicate` `lt(Expression<? extends Number> x, Number y)`

`

`<N extends Number> Expression<N>`

`

`max(Expression<N> x)`

`

`<N extends Number> Expression<N>`

`

`min(Expression<N> x)`

`Expression<Integer>` `mod(Expression<Integer> expression1, Expression<Integer> expression2)`
`Expression<Integer>` `mod(Expression<Integer> expression, Integer integer)`
`Expression<Integer>` `mod(Integer integer, Expression<Integer> expression)`

`

`<N extends Number> Expression<N>`

`

`neg(Expression<N> expression)`

`Predicate` `not(Expression<Boolean> expression)`
`Predicate` `notEqual(Expression<?> x, Expression<?> y)`
`Predicate` `notEqual(Expression<?> x, Object y)`
`Predicate` `notLike(Expression<String> matchExpression, Expression<String> pattern)`
`Predicate` `notLike(Expression<String> matchExpression, Expression<String> pattern, char escapeCharacter)`
`Predicate` `notLike(Expression<String> matchExpression, Expression<String> pattern, Expression<Character> escapeCharacter)`
`Predicate` `notLike(Expression<String> matchExpression, String pattern)`
`Predicate` `notLike(Expression<String> matchExpression, String pattern, char escapeCharacter)`
`Predicate` `notLike(Expression<String> matchExpression, String pattern, Expression<Character> escapeCharacter)`

`

`<Y> Expression<Y>`

`

`nullif(Class<Y> type, Expression<Y> exp1, Expression<?> exp2)`

`

`<Y> Expression<Y>`

`

`nullif(Class<Y> type, Expression<Y> exp1, Y exp2)`

`

`<Y> Expression<Y>`

`

`nullif(Expression<Y> exp1, Expression<?> exp2)`

`

`<Y> Expression<Y>`

`

`nullif(Expression<Y> exp1, Y exp2)`

`

`<T> Expression<T>`

`

`nullLiteral(Class<T> resultClass)`

`Predicate` `or(Expression<Boolean> x, Expression<Boolean> y)`
`Predicate` `or(Predicate... restrictions)`

`

`<T> ParameterExpression<T>`

`

`parameter(Class<T> paramClass)`

`

`<T> ParameterExpression<T>`

`

`parameter(Class<T> paramClass, String name)`

`

`<N extends Number> Expression<N>`

`

`prod(Expression<? extends N> expression1, Expression<? extends N> expression2)`

`

`<N extends Number> Expression<N>`

`

`prod(Expression<? extends N> expression, N n)`

`

`<N extends Number> Expression<N>`

`

`prod(N n, Expression<? extends N> expression)`

`Expression<Number>` `quot(Expression<? extends Number> expression1, Expression<? extends Number> expression2)`
`Expression<Number>` `quot(Expression<? extends Number> expression, Number number)`
`Expression<Number>` `quot(Number number, Expression<? extends Number> expression)`

`

`<R> CriteriaBuilder.Case<R>`

`

`selectCase()`

`

`<R> CriteriaBuilder.Case<R>`

`

`selectCase(Class<R> type)`

`

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

`

`selectCase(Class<R> type, Expression<? extends C> expression)`

`

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

`

`selectCase(Expression<? extends C> expression)`

`

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

`

`size(C c)`

`

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

`

`size(Expression<C> exp)`

`

`<Y> Expression<Y>`

`

`some(Subquery<Y> subquery)`

`Expression<Double>` `sqrt(Expression<? extends Number> expression)`
`Expression<String>` `substring(Expression<String> value, Expression<Integer> start)`
`Expression<String>` `substring(Expression<String> value, Expression<Integer> start, Expression<Integer> length)`
`Expression<String>` `substring(Expression<String> value, int start)`
`Expression<String>` `substring(Expression<String> value, int start, int length)`

`

`<N extends Number> Expression<N>`

`

`sum(Expression<? extends N> expression1, Expression<? extends N> expression2)`

`

`<N extends Number> Expression<N>`

`

`sum(Expression<? extends N> expression, N n)`

`

`<N extends Number> Expression<N>`

`

`sum(Expression<N> x)`

`

`<N extends Number> Expression<N>`

`

`sum(N n, Expression<? extends N> expression)`

`Expression<Double>` `sumAsDouble(Expression<Float> x)`
`Expression<Long>` `sumAsLong(Expression<Integer> x)`
`ExpressionImplementor<BigDecimal>` `toBigDecimal(Expression<? extends Number> expression)`
`ExpressionImplementor<BigInteger>` `toBigInteger(Expression<? extends Number> expression)`
`ExpressionImplementor<Double>` `toDouble(Expression<? extends Number> expression)`
`ExpressionImplementor<Float>` `toFloat(Expression<? extends Number> expression)`
`ExpressionImplementor<Integer>` `toInteger(Expression<? extends Number> expression)`
`ExpressionImplementor<Long>` `toLong(Expression<? extends Number> expression)`
`ExpressionImplementor<String>` `toString(Expression<Character> characterExpression)`
`Expression<String>` `trim(char trimCharacter, Expression<String> trimSource)`
`Expression<String>` `trim(CriteriaBuilder.Trimspec trimspec, char trimCharacter, Expression<String> trimSource)`
`Expression<String>` `trim(CriteriaBuilder.Trimspec trimspec, Expression<Character> trimCharacter, Expression<String> trimSource)`
`Expression<String>` `trim(CriteriaBuilder.Trimspec trimspec, Expression<String> trimSource)`
`Expression<String>` `trim(Expression<Character> trimCharacter, Expression<String> trimSource)`
`Expression<String>` `trim(Expression<String> trimSource)`
`CompoundSelection<Tuple>` `tuple(List<Selection<?>> selections)` Version of `tuple(Selection[])` taking a list.
`CompoundSelection<Tuple>` `tuple(Selection<?>... selections)`
`Expression<String>` `upper(Expression<String> value)`

`

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

`

`values(M map)`

`Predicate` `wrap(Expression<Boolean> expression)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### CriteriaBuilderImpl

    public CriteriaBuilderImpl(EntityManagerFactoryImpl entityManagerFactory)

Method Detail

### getEntityManagerFactory

    public EntityManagerFactoryImpl getEntityManagerFactory()

  Provides protected access to the underlying `EntityManagerFactoryImpl`.

  Returns:
    The underlying `EntityManagerFactoryImpl`

### createQuery

    public CriteriaQuery<Object> createQuery()

  Specified by:
    `createQuery` in interface `CriteriaBuilder`

### createQuery

    public <T> CriteriaQuery<T> createQuery(Class<T> resultClass)

  Specified by:
    `createQuery` in interface `CriteriaBuilder`

### createTupleQuery

    public CriteriaQuery<Tuple> createTupleQuery()

  Specified by:
    `createTupleQuery` in interface `CriteriaBuilder`

### tuple

    public CompoundSelection<Tuple> tuple(Selection<?>... selections)

  Specified by:
    `tuple` in interface `CriteriaBuilder`

### tuple

    public CompoundSelection<Tuple> tuple(List<Selection<?>> selections)

  Version of `tuple(Selection[])` taking a list.

  Parameters:
    `selections` - List of selections.
  Returns:
    The tuple compound selection

### array

    public CompoundSelection<Object[]> array(Selection<?>... selections)

  Specified by:
    `array` in interface `CriteriaBuilder`

### array

    public CompoundSelection<Object[]> array(List<Selection<?>> selections)

  Version of `array(Selection[])` taking a list of selections.

  Parameters:
    `selections` - List of selections.
  Returns:
    The array compound selection

### array

    public <Y> CompoundSelection<Y> array(Class<Y> type,
                                          List<Selection<?>> selections)

  Version of `array(Selection[])` taking a list of selections, as well as the type of array.

  Parameters:
    `type` - The type of array
    `selections` - List of selections.
  Returns:
    The array compound selection

### construct

    public <Y> CompoundSelection<Y> construct(Class<Y> result,
                                              Selection<?>... selections)

  Specified by:
    `construct` in interface `CriteriaBuilder`

### construct

    public <Y> CompoundSelection<Y> construct(Class<Y> result,
                                              List<Selection<?>> selections)

  Version of `construct(Class,Selection[])` taking the to-be-constructed type as well as a list of selections.

  Parameters:
    `result` - The result class to be constructed.
    `selections` - The selections to use in the constructor call.
  Returns:
    The view compound selection.

### asc

    public Order asc(Expression<?> x)

  Specified by:
    `asc` in interface `CriteriaBuilder`

### desc

    public Order desc(Expression<?> x)

  Specified by:
    `desc` in interface `CriteriaBuilder`

### wrap

    public Predicate wrap(Expression<Boolean> expression)

### not

    public Predicate not(Expression<Boolean> expression)

  Specified by:
    `not` in interface `CriteriaBuilder`

### and

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

  Specified by:
    `and` in interface `CriteriaBuilder`

### or

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

  Specified by:
    `or` in interface `CriteriaBuilder`

### and

    public Predicate and(Predicate... restrictions)

  Specified by:
    `and` in interface `CriteriaBuilder`

### or

    public Predicate or(Predicate... restrictions)

  Specified by:
    `or` in interface `CriteriaBuilder`

### conjunction

    public Predicate conjunction()

  Specified by:
    `conjunction` in interface `CriteriaBuilder`

### disjunction

    public Predicate disjunction()

  Specified by:
    `disjunction` in interface `CriteriaBuilder`

### isTrue

    public Predicate isTrue(Expression<Boolean> expression)

  Specified by:
    `isTrue` in interface `CriteriaBuilder`

### isFalse

    public Predicate isFalse(Expression<Boolean> expression)

  Specified by:
    `isFalse` in interface `CriteriaBuilder`

### isNull

    public Predicate isNull(Expression<?> x)

  s

  Specified by:
    `isNull` in interface `CriteriaBuilder`

### isNotNull

    public Predicate isNotNull(Expression<?> x)

  Specified by:
    `isNotNull` in interface `CriteriaBuilder`

### equal

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

  Specified by:
    `equal` in interface `CriteriaBuilder`

### notEqual

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

  Specified by:
    `notEqual` in interface `CriteriaBuilder`

### equal

    public Predicate equal(Expression<?> x,
                           Object y)

  Specified by:
    `equal` in interface `CriteriaBuilder`

### notEqual

    public Predicate notEqual(Expression<?> x,
                              Object y)

  Specified by:
    `notEqual` in interface `CriteriaBuilder`

### greaterThan

    public <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x,
                                                                   Expression<? extends Y> y)

  Specified by:
    `greaterThan` in interface `CriteriaBuilder`

### lessThan

    public <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> x,
                                                                Expression<? extends Y> y)

  Specified by:
    `lessThan` in interface `CriteriaBuilder`

### greaterThanOrEqualTo

    public <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> x,
                                                                            Expression<? extends Y> y)

  Specified by:
    `greaterThanOrEqualTo` in interface `CriteriaBuilder`

### lessThanOrEqualTo

    public <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> x,
                                                                         Expression<? extends Y> y)

  Specified by:
    `lessThanOrEqualTo` in interface `CriteriaBuilder`

### greaterThan

    public <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x,
                                                                   Y y)

  Specified by:
    `greaterThan` in interface `CriteriaBuilder`

### lessThan

    public <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> x,
                                                                Y y)

  Specified by:
    `lessThan` in interface `CriteriaBuilder`

### greaterThanOrEqualTo

    public <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> x,
                                                                            Y y)

  Specified by:
    `greaterThanOrEqualTo` in interface `CriteriaBuilder`

### lessThanOrEqualTo

    public <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> x,
                                                                         Y y)

  Specified by:
    `lessThanOrEqualTo` in interface `CriteriaBuilder`

### gt

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

  Specified by:
    `gt` in interface `CriteriaBuilder`

### lt

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

  Specified by:
    `lt` in interface `CriteriaBuilder`

### ge

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

  Specified by:
    `ge` in interface `CriteriaBuilder`

### le

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

  Specified by:
    `le` in interface `CriteriaBuilder`

### gt

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

  Specified by:
    `gt` in interface `CriteriaBuilder`

### lt

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

  Specified by:
    `lt` in interface `CriteriaBuilder`

### ge

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

  Specified by:
    `ge` in interface `CriteriaBuilder`

### le

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

  Specified by:
    `le` in interface `CriteriaBuilder`

### between

    public <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> expression,
                                                               Y lowerBound,
                                                               Y upperBound)

  Specified by:
    `between` in interface `CriteriaBuilder`

### between

    public <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> expression,
                                                               Expression<? extends Y> lowerBound,
                                                               Expression<? extends Y> upperBound)

  Specified by:
    `between` in interface `CriteriaBuilder`

### in

    public <T> CriteriaBuilder.In<T> in(Expression<? extends T> expression)

  Specified by:
    `in` in interface `CriteriaBuilder`

### in

    public <T> CriteriaBuilder.In<T> in(Expression<? extends T> expression,
                                        Expression<? extends T>... values)

### in

    public <T> CriteriaBuilder.In<T> in(Expression<? extends T> expression,
                                        T... values)

### in

    public <T> CriteriaBuilder.In<T> in(Expression<? extends T> expression,
                                        Collection<T> values)

### like

    public Predicate like(Expression<String> matchExpression,
                          Expression<String> pattern)

  Specified by:
    `like` in interface `CriteriaBuilder`

### like

    public Predicate like(Expression<String> matchExpression,
                          Expression<String> pattern,
                          Expression<Character> escapeCharacter)

  Specified by:
    `like` in interface `CriteriaBuilder`

### like

    public Predicate like(Expression<String> matchExpression,
                          Expression<String> pattern,
                          char escapeCharacter)

  Specified by:
    `like` in interface `CriteriaBuilder`

### like

    public Predicate like(Expression<String> matchExpression,
                          String pattern)

  Specified by:
    `like` in interface `CriteriaBuilder`

### like

    public Predicate like(Expression<String> matchExpression,
                          String pattern,
                          Expression<Character> escapeCharacter)

  Specified by:
    `like` in interface `CriteriaBuilder`

### like

    public Predicate like(Expression<String> matchExpression,
                          String pattern,
                          char escapeCharacter)

  Specified by:
    `like` in interface `CriteriaBuilder`

### notLike

    public Predicate notLike(Expression<String> matchExpression,
                             Expression<String> pattern)

  Specified by:
    `notLike` in interface `CriteriaBuilder`

### notLike

    public Predicate notLike(Expression<String> matchExpression,
                             Expression<String> pattern,
                             Expression<Character> escapeCharacter)

  Specified by:
    `notLike` in interface `CriteriaBuilder`

### notLike

    public Predicate notLike(Expression<String> matchExpression,
                             Expression<String> pattern,
                             char escapeCharacter)

  Specified by:
    `notLike` in interface `CriteriaBuilder`

### notLike

    public Predicate notLike(Expression<String> matchExpression,
                             String pattern)

  Specified by:
    `notLike` in interface `CriteriaBuilder`

### notLike

    public Predicate notLike(Expression<String> matchExpression,
                             String pattern,
                             Expression<Character> escapeCharacter)

  Specified by:
    `notLike` in interface `CriteriaBuilder`

### notLike

    public Predicate notLike(Expression<String> matchExpression,
                             String pattern,
                             char escapeCharacter)

  Specified by:
    `notLike` in interface `CriteriaBuilder`

### parameter

    public <T> ParameterExpression<T> parameter(Class<T> paramClass)

  Specified by:
    `parameter` in interface `CriteriaBuilder`

### parameter

    public <T> ParameterExpression<T> parameter(Class<T> paramClass,
                                                String name)

  Specified by:
    `parameter` in interface `CriteriaBuilder`

### literal

    public <T> Expression<T> literal(T value)

  Specified by:
    `literal` in interface `CriteriaBuilder`

### nullLiteral

    public <T> Expression<T> nullLiteral(Class<T> resultClass)

  Specified by:
    `nullLiteral` in interface `CriteriaBuilder`

### avg

    public <N extends Number> Expression<Double> avg(Expression<N> x)

  Specified by:
    `avg` in interface `CriteriaBuilder`

### sum

    public <N extends Number> Expression<N> sum(Expression<N> x)

  Specified by:
    `sum` in interface `CriteriaBuilder`

### sumAsLong

    public Expression<Long> sumAsLong(Expression<Integer> x)

  Specified by:
    `sumAsLong` in interface `CriteriaBuilder`

### sumAsDouble

    public Expression<Double> sumAsDouble(Expression<Float> x)

  Specified by:
    `sumAsDouble` in interface `CriteriaBuilder`

### max

    public <N extends Number> Expression<N> max(Expression<N> x)

  Specified by:
    `max` in interface `CriteriaBuilder`

### min

    public <N extends Number> Expression<N> min(Expression<N> x)

  Specified by:
    `min` in interface `CriteriaBuilder`

### greatest

    public <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> x)

  Specified by:
    `greatest` in interface `CriteriaBuilder`

### least

    public <X extends Comparable<? super X>> Expression<X> least(Expression<X> x)

  Specified by:
    `least` in interface `CriteriaBuilder`

### count

    public Expression<Long> count(Expression<?> x)

  Specified by:
    `count` in interface `CriteriaBuilder`

### countDistinct

    public Expression<Long> countDistinct(Expression<?> x)

  Specified by:
    `countDistinct` in interface `CriteriaBuilder`

### function

    public <T> Expression<T> function(String name,
                                      Class<T> returnType,
                                      Expression<?>... arguments)

  Specified by:
    `function` in interface `CriteriaBuilder`

### function

    public <T> Expression<T> function(String name,
                                      Class<T> returnType)

  Create a reference to a function taking no params.

  Parameters:
    `name` - The function name.
    `returnType` - The return type.
  Returns:
    The function expression

### abs

    public <N extends Number> Expression<N> abs(Expression<N> expression)

  Specified by:
    `abs` in interface `CriteriaBuilder`

### sqrt

    public Expression<Double> sqrt(Expression<? extends Number> expression)

  Specified by:
    `sqrt` in interface `CriteriaBuilder`

### currentDate

    public Expression<Date> currentDate()

  Specified by:
    `currentDate` in interface `CriteriaBuilder`

### currentTimestamp

    public Expression<Timestamp> currentTimestamp()

  Specified by:
    `currentTimestamp` in interface `CriteriaBuilder`

### currentTime

    public Expression<Time> currentTime()

  Specified by:
    `currentTime` in interface `CriteriaBuilder`

### substring

    public Expression<String> substring(Expression<String> value,
                                        Expression<Integer> start)

  Specified by:
    `substring` in interface `CriteriaBuilder`

### substring

    public Expression<String> substring(Expression<String> value,
                                        int start)

  Specified by:
    `substring` in interface `CriteriaBuilder`

### substring

    public Expression<String> substring(Expression<String> value,
                                        Expression<Integer> start,
                                        Expression<Integer> length)

  Specified by:
    `substring` in interface `CriteriaBuilder`

### substring

    public Expression<String> substring(Expression<String> value,
                                        int start,
                                        int length)

  Specified by:
    `substring` in interface `CriteriaBuilder`

### trim

    public Expression<String> trim(Expression<String> trimSource)

  Specified by:
    `trim` in interface `CriteriaBuilder`

### trim

    public Expression<String> trim(CriteriaBuilder.Trimspec trimspec,
                                   Expression<String> trimSource)

  Specified by:
    `trim` in interface `CriteriaBuilder`

### trim

    public Expression<String> trim(Expression<Character> trimCharacter,
                                   Expression<String> trimSource)

  Specified by:
    `trim` in interface `CriteriaBuilder`

### trim

    public Expression<String> trim(CriteriaBuilder.Trimspec trimspec,
                                   Expression<Character> trimCharacter,
                                   Expression<String> trimSource)

  Specified by:
    `trim` in interface `CriteriaBuilder`

### trim

    public Expression<String> trim(char trimCharacter,
                                   Expression<String> trimSource)

  Specified by:
    `trim` in interface `CriteriaBuilder`

### trim

    public Expression<String> trim(CriteriaBuilder.Trimspec trimspec,
                                   char trimCharacter,
                                   Expression<String> trimSource)

  Specified by:
    `trim` in interface `CriteriaBuilder`

### lower

    public Expression<String> lower(Expression<String> value)

  Specified by:
    `lower` in interface `CriteriaBuilder`

### upper

    public Expression<String> upper(Expression<String> value)

  Specified by:
    `upper` in interface `CriteriaBuilder`

### length

    public Expression<Integer> length(Expression<String> value)

  Specified by:
    `length` in interface `CriteriaBuilder`

### locate

    public Expression<Integer> locate(Expression<String> string,
                                      Expression<String> pattern)

  Specified by:
    `locate` in interface `CriteriaBuilder`

### locate

    public Expression<Integer> locate(Expression<String> string,
                                      Expression<String> pattern,
                                      Expression<Integer> start)

  Specified by:
    `locate` in interface `CriteriaBuilder`

### locate

    public Expression<Integer> locate(Expression<String> string,
                                      String pattern)

  Specified by:
    `locate` in interface `CriteriaBuilder`

### locate

    public Expression<Integer> locate(Expression<String> string,
                                      String pattern,
                                      int start)

  Specified by:
    `locate` in interface `CriteriaBuilder`

### neg

    public <N extends Number> Expression<N> neg(Expression<N> expression)

  Specified by:
    `neg` in interface `CriteriaBuilder`

### sum

    public <N extends Number> Expression<N> sum(Expression<? extends N> expression1,
                                                Expression<? extends N> expression2)

  Specified by:
    `sum` in interface `CriteriaBuilder`

### prod

    public <N extends Number> Expression<N> prod(Expression<? extends N> expression1,
                                                 Expression<? extends N> expression2)

  Specified by:
    `prod` in interface `CriteriaBuilder`

### diff

    public <N extends Number> Expression<N> diff(Expression<? extends N> expression1,
                                                 Expression<? extends N> expression2)

  Specified by:
    `diff` in interface `CriteriaBuilder`

### sum

    public <N extends Number> Expression<N> sum(Expression<? extends N> expression,
                                                N n)

  Specified by:
    `sum` in interface `CriteriaBuilder`

### prod

    public <N extends Number> Expression<N> prod(Expression<? extends N> expression,
                                                 N n)

  Specified by:
    `prod` in interface `CriteriaBuilder`

### diff

    public <N extends Number> Expression<N> diff(Expression<? extends N> expression,
                                                 N n)

  Specified by:
    `diff` in interface `CriteriaBuilder`

### sum

    public <N extends Number> Expression<N> sum(N n,
                                                Expression<? extends N> expression)

  Specified by:
    `sum` in interface `CriteriaBuilder`

### prod

    public <N extends Number> Expression<N> prod(N n,
                                                 Expression<? extends N> expression)

  Specified by:
    `prod` in interface `CriteriaBuilder`

### diff

    public <N extends Number> Expression<N> diff(N n,
                                                 Expression<? extends N> expression)

  Specified by:
    `diff` in interface `CriteriaBuilder`

### quot

    public Expression<Number> quot(Expression<? extends Number> expression1,
                                   Expression<? extends Number> expression2)

  Specified by:
    `quot` in interface `CriteriaBuilder`

### quot

    public Expression<Number> quot(Expression<? extends Number> expression,
                                   Number number)

  Specified by:
    `quot` in interface `CriteriaBuilder`

### quot

    public Expression<Number> quot(Number number,
                                   Expression<? extends Number> expression)

  Specified by:
    `quot` in interface `CriteriaBuilder`

### mod

    public Expression<Integer> mod(Expression<Integer> expression1,
                                   Expression<Integer> expression2)

  Specified by:
    `mod` in interface `CriteriaBuilder`

### mod

    public Expression<Integer> mod(Expression<Integer> expression,
                                   Integer integer)

  Specified by:
    `mod` in interface `CriteriaBuilder`

### mod

    public Expression<Integer> mod(Integer integer,
                                   Expression<Integer> expression)

  Specified by:
    `mod` in interface `CriteriaBuilder`

### toLong

    public ExpressionImplementor<Long> toLong(Expression<? extends Number> expression)

  Specified by:
    `toLong` in interface `CriteriaBuilder`

### toInteger

    public ExpressionImplementor<Integer> toInteger(Expression<? extends Number> expression)

  Specified by:
    `toInteger` in interface `CriteriaBuilder`

### toFloat

    public ExpressionImplementor<Float> toFloat(Expression<? extends Number> expression)

  Specified by:
    `toFloat` in interface `CriteriaBuilder`

### toDouble

    public ExpressionImplementor<Double> toDouble(Expression<? extends Number> expression)

  Specified by:
    `toDouble` in interface `CriteriaBuilder`

### toBigDecimal

    public ExpressionImplementor<BigDecimal> toBigDecimal(Expression<? extends Number> expression)

  Specified by:
    `toBigDecimal` in interface `CriteriaBuilder`

### toBigInteger

    public ExpressionImplementor<BigInteger> toBigInteger(Expression<? extends Number> expression)

  Specified by:
    `toBigInteger` in interface `CriteriaBuilder`

### toString

    public ExpressionImplementor<String> toString(Expression<Character> characterExpression)

  Specified by:
    `toString` in interface `CriteriaBuilder`

### exists

    public Predicate exists(Subquery<?> subquery)

  Specified by:
    `exists` in interface `CriteriaBuilder`

### all

    public <Y> Expression<Y> all(Subquery<Y> subquery)

  Specified by:
    `all` in interface `CriteriaBuilder`

### some

    public <Y> Expression<Y> some(Subquery<Y> subquery)

  Specified by:
    `some` in interface `CriteriaBuilder`

### any

    public <Y> Expression<Y> any(Subquery<Y> subquery)

  Specified by:
    `any` in interface `CriteriaBuilder`

### coalesce

    public <Y> Expression<Y> coalesce(Expression<? extends Y> exp1,
                                      Expression<? extends Y> exp2)

  Specified by:
    `coalesce` in interface `CriteriaBuilder`

### coalesce

    public <Y> Expression<Y> coalesce(Class<Y> type,
                                      Expression<? extends Y> exp1,
                                      Expression<? extends Y> exp2)

### coalesce

    public <Y> Expression<Y> coalesce(Expression<? extends Y> exp1,
                                      Y exp2)

  Specified by:
    `coalesce` in interface `CriteriaBuilder`

### coalesce

    public <Y> Expression<Y> coalesce(Class<Y> type,
                                      Expression<? extends Y> exp1,
                                      Y exp2)

### coalesce

    public <T> CriteriaBuilder.Coalesce<T> coalesce()

  Specified by:
    `coalesce` in interface `CriteriaBuilder`

### coalesce

    public <T> CriteriaBuilder.Coalesce<T> coalesce(Class<T> type)

### concat

    public Expression<String> concat(Expression<String> string1,
                                     Expression<String> string2)

  Specified by:
    `concat` in interface `CriteriaBuilder`

### concat

    public Expression<String> concat(Expression<String> string1,
                                     String string2)

  Specified by:
    `concat` in interface `CriteriaBuilder`

### concat

    public Expression<String> concat(String string1,
                                     Expression<String> string2)

  Specified by:
    `concat` in interface `CriteriaBuilder`

### nullif

    public <Y> Expression<Y> nullif(Expression<Y> exp1,
                                    Expression<?> exp2)

  Specified by:
    `nullif` in interface `CriteriaBuilder`

### nullif

    public <Y> Expression<Y> nullif(Class<Y> type,
                                    Expression<Y> exp1,
                                    Expression<?> exp2)

### nullif

    public <Y> Expression<Y> nullif(Expression<Y> exp1,
                                    Y exp2)

  Specified by:
    `nullif` in interface `CriteriaBuilder`

### nullif

    public <Y> Expression<Y> nullif(Class<Y> type,
                                    Expression<Y> exp1,
                                    Y exp2)

### selectCase

    public <C,R> CriteriaBuilder.SimpleCase<C,R> selectCase(Expression<? extends C> expression)

  Specified by:
    `selectCase` in interface `CriteriaBuilder`

### selectCase

    public <C,R> CriteriaBuilder.SimpleCase<C,R> selectCase(Class<R> type,
                                                            Expression<? extends C> expression)

### selectCase

    public <R> CriteriaBuilder.Case<R> selectCase()

  Specified by:
    `selectCase` in interface `CriteriaBuilder`

### selectCase

    public <R> CriteriaBuilder.Case<R> selectCase(Class<R> type)

### size

    public <C extends Collection<?>> Expression<Integer> size(C c)

  Specified by:
    `size` in interface `CriteriaBuilder`

### size

    public <C extends Collection<?>> Expression<Integer> size(Expression<C> exp)

  Specified by:
    `size` in interface `CriteriaBuilder`

### values

    public <V,M extends Map<?,V>> Expression<Collection<V>> values(M map)

  Specified by:
    `values` in interface `CriteriaBuilder`

### keys

    public <K,M extends Map<K,?>> Expression<Set<K>> keys(M map)

  Specified by:
    `keys` in interface `CriteriaBuilder`

### isEmpty

    public <C extends Collection<?>> Predicate isEmpty(Expression<C> collectionExpression)

  Specified by:
    `isEmpty` in interface `CriteriaBuilder`

### isNotEmpty

    public <C extends Collection<?>> Predicate isNotEmpty(Expression<C> collectionExpression)

  Specified by:
    `isNotEmpty` in interface `CriteriaBuilder`

### isMember

    public <E,C extends Collection<E>> Predicate isMember(E e,
                                                          Expression<C> collectionExpression)

  Specified by:
    `isMember` in interface `CriteriaBuilder`

### isNotMember

    public <E,C extends Collection<E>> Predicate isNotMember(E e,
                                                             Expression<C> cExpression)

  Specified by:
    `isNotMember` in interface `CriteriaBuilder`

### isMember

    public <E,C extends Collection<E>> Predicate isMember(Expression<E> elementExpression,
                                                          Expression<C> collectionExpression)

  Specified by:
    `isMember` in interface `CriteriaBuilder`

### isNotMember

    public <E,C extends Collection<E>> Predicate isNotMember(Expression<E> eExpression,
                                                             Expression<C> cExpression)

  Specified by:
    `isNotMember` in interface `CriteriaBuilder`

Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.