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<Boolean>` in this API in order to work around the fact that Java generics are not compatible with varags.

  Since:
    Java Persistence 2.0

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Interface and Description
    --- | ---
    `static interface` | `CriteriaBuilder.Case<R>` Interface used to build general case expressions.
    `static interface` | `CriteriaBuilder.Coalesce<T>` Interface used to build coalesce expressions.
    `static interface` | `CriteriaBuilder.In<T>` Interface used to build in predicates.
    `static interface` | `CriteriaBuilder.SimpleCase<C,R>` Interface used to build simple case expressions.
    `static class` | `CriteriaBuilder.Trimspec` Used to specify how strings are trimmed.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `<N extends Number> Expression<N>` | `abs(Expression<N> x)` Create an expression that returns the absolute value of its argument.
    `<Y> Expression<Y>` | `all(Subquery<Y> subquery)` Create an all expression over the subquery results.
    `Predicate` | `and(Expression<Boolean> x, Expression<Boolean> y)` Create a conjunction of the given boolean expressions.
    `Predicate` | `and(Predicate... restrictions)` Create a conjunction of the given restriction predicates.
    `<Y> Expression<Y>` | `any(Subquery<Y> subquery)` Create an any expression over the subquery results.
    `CompoundSelection<Object[]>` | `array(Selection<?>... selections)` Create an array-valued selection item.
    `Order` | `asc(Expression<?> x)` Create an ordering by the ascending value of the expression.
    `<N extends Number> Expression<Double>` | `avg(Expression<N> x)` Create an aggregate expression applying the avg operation.
    `<Y extends Comparable<? super Y>> Predicate` | `between(Expression<? extends Y> v, Expression<? extends Y> x, Expression<? extends Y> y)` Create a predicate for testing whether the first argument is between the second and third arguments in value.
    `<Y extends Comparable<? super Y>> Predicate` | `between(Expression<? extends Y> v, Y x, Y y)` Create a predicate for testing whether the first argument is between the second and third arguments in value.
    `<T> CriteriaBuilder.Coalesce<T>` | `coalesce()` Create a coalesce expression.
    `<Y> Expression<Y>` | `coalesce(Expression<? extends Y> x, Expression<? extends Y> y)` Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
    `<Y> Expression<Y>` | `coalesce(Expression<? extends Y> x, Y y)` Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
    `Expression<String>` | `concat(Expression<String> x, Expression<String> y)` Create an expression for string concatenation.
    `Expression<String>` | `concat(Expression<String> x, String y)` Create an expression for string concatenation.
    `Expression<String>` | `concat(String x, Expression<String> y)` Create an expression for string concatenation.
    `Predicate` | `conjunction()` Create a conjunction (with zero conjuncts).
    `<Y> CompoundSelection<Y>` | `construct(Class<Y> resultClass, Selection<?>... selections)` Create a selection item corresponding to a constructor.
    `Expression<Long>` | `count(Expression<?> x)` Create an aggregate expression applying the count operation.
    `Expression<Long>` | `countDistinct(Expression<?> x)` Create an aggregate expression applying the count distinct operation.
    `<T> CriteriaDelete<T>` | `createCriteriaDelete(Class<T> targetEntity)` Create a `CriteriaDelete` query object to perform a bulk delete operation.
    `<T> CriteriaUpdate<T>` | `createCriteriaUpdate(Class<T> targetEntity)` Create a `CriteriaUpdate` query object to perform a bulk update operation.
    `CriteriaQuery<Object>` | `createQuery()` Create a `CriteriaQuery` object.
    `<T> CriteriaQuery<T>` | `createQuery(Class<T> resultClass)` Create a `CriteriaQuery` object with the specified result type.
    `CriteriaQuery<Tuple>` | `createTupleQuery()` Create a `CriteriaQuery` object that returns a tuple of objects as its result.
    `Expression<Date>` | `currentDate()` Create expression to return current date.
    `Expression<Time>` | `currentTime()` Create expression to return current time.
    `Expression<Timestamp>` | `currentTimestamp()` Create expression to return current timestamp.
    `Order` | `desc(Expression<?> x)` Create an ordering by the descending value of the expression.
    `<N extends Number> Expression<N>` | `diff(Expression<? extends N> x, Expression<? extends N> y)` Create an expression that returns the difference between its arguments.
    `<N extends Number> Expression<N>` | `diff(Expression<? extends N> x, N y)` Create an expression that returns the difference between its arguments.
    `<N extends Number> Expression<N>` | `diff(N x, Expression<? extends N> y)` Create an expression that returns the difference between its arguments.
    `Predicate` | `disjunction()` Create a disjunction (with zero disjuncts).
    `Predicate` | `equal(Expression<?> x, Expression<?> y)` Create a predicate for testing the arguments for equality.
    `Predicate` | `equal(Expression<?> x, Object y)` Create a predicate for testing the arguments for equality.
    `Predicate` | `exists(Subquery<?> subquery)` Create a predicate testing the existence of a subquery result.
    `<T> Expression<T>` | `function(String name, Class<T> type, Expression<?>... args)` Create an expression for the execution of a database function.
    `Predicate` | `ge(Expression<? extends Number> x, Expression<? extends Number> y)` Create a predicate for testing whether the first argument is greater than or equal to the second.
    `Predicate` | `ge(Expression<? extends Number> x, Number y)` Create a predicate for testing whether the first argument is greater than or equal to the second.
    `<Y extends Comparable<? super Y>> Predicate` | `greaterThan(Expression<? extends Y> x, Expression<? extends Y> y)` Create a predicate for testing whether the first argument is greater than the second.
    `<Y extends Comparable<? super Y>> Predicate` | `greaterThan(Expression<? extends Y> x, Y y)` Create a predicate for testing whether the first argument is greater than the second.
    `<Y extends Comparable<? super Y>> Predicate` | `greaterThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y)` Create a predicate for testing whether the first argument is greater than or equal to the second.
    `<Y extends Comparable<? super Y>> Predicate` | `greaterThanOrEqualTo(Expression<? extends Y> x, Y y)` Create a predicate for testing whether the first argument is greater than or equal to the second.
    `<X extends Comparable<? super X>> Expression<X>` | `greatest(Expression<X> x)` Create an aggregate expression for finding the greatest of the values (strings, dates, etc).
    `Predicate` | `gt(Expression<? extends Number> x, Expression<? extends Number> y)` Create a predicate for testing whether the first argument is greater than the second.
    `Predicate` | `gt(Expression<? extends Number> x, Number y)` Create a predicate for testing whether the first argument is greater than the second.
    `<T> CriteriaBuilder.In<T>` | `in(Expression<? extends T> expression)` Create predicate to test whether given expression is contained in a list of values.
    `<C extends Collection<?>> Predicate` | `isEmpty(Expression<C> collection)` Create a predicate that tests whether a collection is empty.
    `Predicate` | `isFalse(Expression<Boolean> x)` Create a predicate testing for a false value.
    `<E,C extends Collection<E>> Predicate` | `isMember(E elem, Expression<C> collection)` Create a predicate that tests whether an element is a member of a collection.
    `<E,C extends Collection<E>> Predicate` | `isMember(Expression<E> elem, Expression<C> collection)` Create a predicate that tests whether an element is a member of a collection.
    `<C extends Collection<?>> Predicate` | `isNotEmpty(Expression<C> collection)` Create a predicate that tests whether a collection is not empty.
    `<E,C extends Collection<E>> Predicate` | `isNotMember(E elem, Expression<C> collection)` Create a predicate that tests whether an element is not a member of a collection.
    `<E,C extends Collection<E>> Predicate` | `isNotMember(Expression<E> elem, Expression<C> collection)` Create a predicate that tests whether an element is not a member of a collection.
    `Predicate` | `isNotNull(Expression<?> x)` Create a predicate to test whether the expression is not null.
    `Predicate` | `isNull(Expression<?> x)` Create a predicate to test whether the expression is null.
    `Predicate` | `isTrue(Expression<Boolean> x)` Create a predicate testing for a true value.
    `<K,M extends Map<K,?>> Expression<Set<K>>` | `keys(M map)` Create an expression that returns the keys of a map.
    `Predicate` | `le(Expression<? extends Number> x, Expression<? extends Number> y)` Create a predicate for testing whether the first argument is less than or equal to the second.
    `Predicate` | `le(Expression<? extends Number> x, Number y)` Create a predicate for testing whether the first argument is less than or equal to the second.
    `<X extends Comparable<? super X>> Expression<X>` | `least(Expression<X> x)` Create an aggregate expression for finding the least of the values (strings, dates, etc).
    `Expression<Integer>` | `length(Expression<String> x)` Create expression to return length of a string.
    `<Y extends Comparable<? super Y>> Predicate` | `lessThan(Expression<? extends Y> x, Expression<? extends Y> y)` Create a predicate for testing whether the first argument is less than the second.
    `<Y extends Comparable<? super Y>> Predicate` | `lessThan(Expression<? extends Y> x, Y y)` Create a predicate for testing whether the first argument is less than the second.
    `<Y extends Comparable<? super Y>> Predicate` | `lessThanOrEqualTo(Expression<? extends Y> x, Expression<? extends Y> y)` Create a predicate for testing whether the first argument is less than or equal to the second.
    `<Y extends Comparable<? super Y>> Predicate` | `lessThanOrEqualTo(Expression<? extends Y> x, Y y)` Create a predicate for testing whether the first argument is less than or equal to the second.
    `Predicate` | `like(Expression<String> x, Expression<String> pattern)` Create a predicate for testing whether the expression satisfies the given pattern.
    `Predicate` | `like(Expression<String> x, Expression<String> pattern, char escapeChar)` Create a predicate for testing whether the expression satisfies the given pattern.
    `Predicate` | `like(Expression<String> x, Expression<String> pattern, Expression<Character> escapeChar)` Create a predicate for testing whether the expression satisfies the given pattern.
    `Predicate` | `like(Expression<String> x, String pattern)` Create a predicate for testing whether the expression satisfies the given pattern.
    `Predicate` | `like(Expression<String> x, String pattern, char escapeChar)` Create a predicate for testing whether the expression satisfies the given pattern.
    `Predicate` | `like(Expression<String> x, String pattern, Expression<Character> escapeChar)` Create a predicate for testing whether the expression satisfies the given pattern.
    `<T> Expression<T>` | `literal(T value)` Create an expression for a literal.
    `Expression<Integer>` | `locate(Expression<String> x, Expression<String> pattern)` Create expression to locate the position of one string within another, returning position of first character if found.
    `Expression<Integer>` | `locate(Expression<String> x, Expression<String> pattern, Expression<Integer> from)` Create expression to locate the position of one string within another, returning position of first character if found.
    `Expression<Integer>` | `locate(Expression<String> x, String pattern)` Create expression to locate the position of one string within another, returning position of first character if found.
    `Expression<Integer>` | `locate(Expression<String> x, String pattern, int from)` Create expression to locate the position of one string within another, returning position of first character if found.
    `Expression<String>` | `lower(Expression<String> x)` Create expression for converting a string to lowercase.
    `Predicate` | `lt(Expression<? extends Number> x, Expression<? extends Number> y)` Create a predicate for testing whether the first argument is less than the second.
    `Predicate` | `lt(Expression<? extends Number> x, Number y)` Create a predicate for testing whether the first argument is less than the second.
    `<N extends Number> Expression<N>` | `max(Expression<N> x)` Create an aggregate expression applying the numerical max operation.
    `<N extends Number> Expression<N>` | `min(Expression<N> x)` Create an aggregate expression applying the numerical min operation.
    `Expression<Integer>` | `mod(Expression<Integer> x, Expression<Integer> y)` Create an expression that returns the modulus of its arguments.
    `Expression<Integer>` | `mod(Expression<Integer> x, Integer y)` Create an expression that returns the modulus of its arguments.
    `Expression<Integer>` | `mod(Integer x, Expression<Integer> y)` Create an expression that returns the modulus of its arguments.
    `<N extends Number> Expression<N>` | `neg(Expression<N> x)` Create an expression that returns the arithmetic negation of its argument.
    `Predicate` | `not(Expression<Boolean> restriction)` Create a negation of the given restriction.
    `Predicate` | `notEqual(Expression<?> x, Expression<?> y)` Create a predicate for testing the arguments for inequality.
    `Predicate` | `notEqual(Expression<?> x, Object y)` Create a predicate for testing the arguments for inequality.
    `Predicate` | `notLike(Expression<String> x, Expression<String> pattern)` Create a predicate for testing whether the expression does not satisfy the given pattern.
    `Predicate` | `notLike(Expression<String> x, Expression<String> pattern, char escapeChar)` Create a predicate for testing whether the expression does not satisfy the given pattern.
    `Predicate` | `notLike(Expression<String> x, Expression<String> pattern, Expression<Character> escapeChar)` Create a predicate for testing whether the expression does not satisfy the given pattern.
    `Predicate` | `notLike(Expression<String> x, String pattern)` Create a predicate for testing whether the expression does not satisfy the given pattern.
    `Predicate` | `notLike(Expression<String> x, String pattern, char escapeChar)` Create a predicate for testing whether the expression does not satisfy the given pattern.
    `Predicate` | `notLike(Expression<String> x, String pattern, Expression<Character> escapeChar)` Create a predicate for testing whether the expression does not satisfy the given pattern.
    `<Y> Expression<Y>` | `nullif(Expression<Y> x, Expression<?> y)` Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.
    `<Y> Expression<Y>` | `nullif(Expression<Y> x, Y y)` Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.
    `<T> Expression<T>` | `nullLiteral(Class<T> resultClass)` Create an expression for a null literal with the given type.
    `Predicate` | `or(Expression<Boolean> x, Expression<Boolean> y)` Create a disjunction of the given boolean expressions.
    `Predicate` | `or(Predicate... restrictions)` Create a disjunction of the given restriction predicates.
    `<T> ParameterExpression<T>` | `parameter(Class<T> paramClass)` Create a parameter expression.
    `<T> ParameterExpression<T>` | `parameter(Class<T> paramClass, String name)` Create a parameter expression with the given name.
    `<N extends Number> Expression<N>` | `prod(Expression<? extends N> x, Expression<? extends N> y)` Create an expression that returns the product of its arguments.
    `<N extends Number> Expression<N>` | `prod(Expression<? extends N> x, N y)` Create an expression that returns the product of its arguments.
    `<N extends Number> Expression<N>` | `prod(N x, Expression<? extends N> y)` Create an expression that returns the product of its arguments.
    `Expression<Number>` | `quot(Expression<? extends Number> x, Expression<? extends Number> y)` Create an expression that returns the quotient of its arguments.
    `Expression<Number>` | `quot(Expression<? extends Number> x, Number y)` Create an expression that returns the quotient of its arguments.
    `Expression<Number>` | `quot(Number x, Expression<? extends Number> y)` Create an expression that returns the quotient of its arguments.
    `<R> CriteriaBuilder.Case<R>` | `selectCase()` Create a general case expression.
    `<C,R> CriteriaBuilder.SimpleCase<C,R>` | `selectCase(Expression<? extends C> expression)` Create a simple case expression.
    `<C extends Collection<?>> Expression<Integer>` | `size(C collection)` Create an expression that tests the size of a collection.
    `<C extends Collection<?>> Expression<Integer>` | `size(Expression<C> collection)` Create an expression that tests the size of a collection.
    `<Y> Expression<Y>` | `some(Subquery<Y> subquery)` Create a some expression over the subquery results.
    `Expression<Double>` | `sqrt(Expression<? extends Number> x)` Create an expression that returns the square root of its argument.
    `Expression<String>` | `substring(Expression<String> x, 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.
    `<X,T,E extends T> CollectionJoin<X,E>` | `treat(CollectionJoin<X,T> join, Class<E> type)` Downcast CollectionJoin object to the specified type.
    `<X,T,V extends T> Join<X,V>` | `treat(Join<X,T> join, Class<V> type)` Downcast Join object to the specified type.
    `<X,T,E extends T> ListJoin<X,E>` | `treat(ListJoin<X,T> join, Class<E> type)` Downcast ListJoin object to the specified type.
    `<X,K,T,V extends T> MapJoin<X,K,V>` | `treat(MapJoin<X,K,T> join, Class<V> type)` Downcast MapJoin object to the specified type.
    `<X,T extends X> Path<T>` | `treat(Path<X> path, Class<T> type)` Downcast Path object to the specified type.
    `<X,T extends X> Root<T>` | `treat(Root<X> root, Class<T> type)` Downcast Root object to the specified type.
    `<X,T,E extends T> SetJoin<X,E>` | `treat(SetJoin<X,T> join, Class<E> type)` Downcast SetJoin object to the specified type.
    `Expression<String>` | `trim(char t, Expression<String> x)` Create expression to trim character from both ends of a string.
    `Expression<String>` | `trim(CriteriaBuilder.Trimspec ts, char t, Expression<String> x)` Create expression to trim character from a string.
    `Expression<String>` | `trim(CriteriaBuilder.Trimspec ts, Expression<Character> t, Expression<String> x)` Create expression to trim character from a string.
    `Expression<String>` | `trim(CriteriaBuilder.Trimspec ts, Expression<String> x)` Create expression to trim blanks from a string.
    `Expression<String>` | `trim(Expression<Character> t, Expression<String> x)` Create expression to trim character from both ends of a string.
    `Expression<String>` | `trim(Expression<String> x)` Create expression to trim blanks from both ends of a string.
    `CompoundSelection<Tuple>` | `tuple(Selection<?>... selections)` Create a tuple-valued selection item.
    `Expression<String>` | `upper(Expression<String> x)` Create expression for converting a string to uppercase.
    `<V,M extends Map<?,V>> Expression<Collection<V>>` | `values(M map)` Create an expression that returns the values of a map.

- - ### Method 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

    - #### createCriteriaUpdate

          <T> CriteriaUpdate<T> createCriteriaUpdate(Class<T> targetEntity)

      Create a `CriteriaUpdate` query object to perform a bulk update operation.
      Parameters:
        `targetEntity` - target type for update operation
      Returns:
        the query object
      Since:
        Java Persistence 2.1

    - #### createCriteriaDelete

          <T> CriteriaDelete<T> createCriteriaDelete(Class<T> targetEntity)

      Create a `CriteriaDelete` query object to perform a bulk delete operation.
      Parameters:
        `targetEntity` - target type for delete operation
      Returns:
        the query object
      Since:
        Java Persistence 2.1

    - #### construct

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

      Create a selection item corresponding to a constructor. This method is used to specify a constructor that will be applied to the results of the query execution. If the constructor is for an entity class, the resulting entities will be in the new state after the query is executed.
      Parameters:
        `resultClass` - class whose instance is to be constructed
        `selections` - arguments to the constructor
      Returns:
        compound selection item
      Throws:
        `IllegalArgumentException` - if an argument is a tuple- or array-valued selection item

    - #### tuple

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

      Create a tuple-valued selection item.
      Parameters:
        `selections` - selection items
      Returns:
        tuple-valued compound selection
      Throws:
        `IllegalArgumentException` - if an argument is a tuple- or array-valued selection item

    - #### array

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

      Create an array-valued selection item.
      Parameters:
        `selections` - selection items
      Returns:
        array-valued compound selection
      Throws:
        `IllegalArgumentException` - if an argument is a tuple- or array-valued selection item

    - #### asc

          Order asc(Expression<?> x)

      Create an ordering by the ascending value of the expression.
      Parameters:
        `x` - expression used to define the ordering
      Returns:
        ascending ordering corresponding to the expression

    - #### desc

          Order desc(Expression<?> x)

      Create an ordering by the descending value of the expression.
      Parameters:
        `x` - expression used to define the ordering
      Returns:
        descending ordering corresponding to the expression

    - #### avg

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

      Create an aggregate expression applying the avg operation.
      Parameters:
        `x` - expression representing input value to avg operation
      Returns:
        avg expression

    - #### sum

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

      Create an aggregate expression applying the sum operation.
      Parameters:
        `x` - expression representing input value to sum operation
      Returns:
        sum expression

    - #### sumAsLong

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

      Create an aggregate expression applying the sum operation to an Integer-valued expression, returning a Long result.
      Parameters:
        `x` - expression representing input value to sum operation
      Returns:
        sum expression

    - #### sumAsDouble

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

      Create an aggregate expression applying the sum operation to a Float-valued expression, returning a Double result.
      Parameters:
        `x` - expression representing input value to sum operation
      Returns:
        sum expression

    - #### max

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

      Create an aggregate expression applying the numerical max operation.
      Parameters:
        `x` - expression representing input value to max operation
      Returns:
        max expression

    - #### min

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

      Create an aggregate expression applying the numerical min operation.
      Parameters:
        `x` - expression representing input value to min operation
      Returns:
        min expression

    - #### greatest

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

      Create an aggregate expression for finding the greatest of the values (strings, dates, etc).
      Parameters:
        `x` - expression representing input value to greatest operation
      Returns:
        greatest expression

    - #### least

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

      Create an aggregate expression for finding the least of the values (strings, dates, etc).
      Parameters:
        `x` - expression representing input value to least operation
      Returns:
        least expression

    - #### count

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

      Create an aggregate expression applying the count operation.
      Parameters:
        `x` - expression representing input value to count operation
      Returns:
        count expression

    - #### countDistinct

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

      Create an aggregate expression applying the count distinct operation.
      Parameters:
        `x` - expression representing input value to count distinct operation
      Returns:
        count distinct expression

    - #### exists

          Predicate exists(Subquery<?> subquery)

      Create a predicate testing the existence of a subquery result.
      Parameters:
        `subquery` - subquery whose result is to be tested
      Returns:
        exists predicate

    - #### all

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

      Create an all expression over the subquery results.
      Parameters:
        `subquery` - subquery
      Returns:
        all expression

    - #### some

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

      Create a some expression over the subquery results. This expression is equivalent to an `any` expression.
      Parameters:
        `subquery` - subquery
      Returns:
        some expression

    - #### any

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

      Create an any expression over the subquery results. This expression is equivalent to a `some` expression.
      Parameters:
        `subquery` - subquery
      Returns:
        any expression

    - #### and

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

      Create a conjunction of the given boolean expressions.
      Parameters:
        `x` - boolean expression
        `y` - boolean expression
      Returns:
        and predicate

    - #### and

          Predicate and(Predicate... restrictions)

      Create a conjunction of the given restriction predicates. A conjunction of zero predicates is true.
      Parameters:
        `restrictions` - zero or more restriction predicates
      Returns:
        and predicate

    - #### or

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

      Create a disjunction of the given boolean expressions.
      Parameters:
        `x` - boolean expression
        `y` - boolean expression
      Returns:
        or predicate

    - #### or

          Predicate or(Predicate... restrictions)

      Create a disjunction of the given restriction predicates. A disjunction of zero predicates is false.
      Parameters:
        `restrictions` - zero or more restriction predicates
      Returns:
        or predicate

    - #### not

          Predicate not(Expression<Boolean> restriction)

      Create a negation of the given restriction.
      Parameters:
        `restriction` - restriction expression
      Returns:
        not predicate

    - #### conjunction

          Predicate conjunction()

      Create a conjunction (with zero conjuncts). A conjunction with zero conjuncts is true.
      Returns:
        and predicate

    - #### disjunction

          Predicate disjunction()

      Create a disjunction (with zero disjuncts). A disjunction with zero disjuncts is false.
      Returns:
        or predicate

    - #### isTrue

          Predicate isTrue(Expression<Boolean> x)

      Create a predicate testing for a true value.
      Parameters:
        `x` - expression to be tested
      Returns:
        predicate

    - #### isFalse

          Predicate isFalse(Expression<Boolean> x)

      Create a predicate testing for a false value.
      Parameters:
        `x` - expression to be tested
      Returns:
        predicate

    - #### isNull

          Predicate isNull(Expression<?> x)

      Create a predicate to test whether the expression is null.
      Parameters:
        `x` - expression
      Returns:
        is-null predicate

    - #### isNotNull

          Predicate isNotNull(Expression<?> x)

      Create a predicate to test whether the expression is not null.
      Parameters:
        `x` - expression
      Returns:
        is-not-null predicate

    - #### equal

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

      Create a predicate for testing the arguments for equality.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        equality predicate

    - #### equal

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

      Create a predicate for testing the arguments for equality.
      Parameters:
        `x` - expression
        `y` - object
      Returns:
        equality predicate

    - #### notEqual

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

      Create a predicate for testing the arguments for inequality.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        inequality predicate

    - #### notEqual

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

      Create a predicate for testing the arguments for inequality.
      Parameters:
        `x` - expression
        `y` - object
      Returns:
        inequality predicate

    - #### greaterThan

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

      Create a predicate for testing whether the first argument is greater than the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        greater-than predicate

    - #### greaterThan

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

      Create a predicate for testing whether the first argument is greater than the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        greater-than predicate

    - #### greaterThanOrEqualTo

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

      Create a predicate for testing whether the first argument is greater than or equal to the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        greater-than-or-equal predicate

    - #### greaterThanOrEqualTo

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

      Create a predicate for testing whether the first argument is greater than or equal to the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        greater-than-or-equal predicate

    - #### lessThan

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

      Create a predicate for testing whether the first argument is less than the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        less-than predicate

    - #### lessThan

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

      Create a predicate for testing whether the first argument is less than the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        less-than predicate

    - #### lessThanOrEqualTo

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

      Create a predicate for testing whether the first argument is less than or equal to the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        less-than-or-equal predicate

    - #### lessThanOrEqualTo

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

      Create a predicate for testing whether the first argument is less than or equal to the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        less-than-or-equal predicate

    - #### between

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

      Create a predicate for testing whether the first argument is between the second and third arguments in value.
      Parameters:
        `v` - expression
        `x` - expression
        `y` - expression
      Returns:
        between predicate

    - #### between

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

      Create a predicate for testing whether the first argument is between the second and third arguments in value.
      Parameters:
        `v` - expression
        `x` - value
        `y` - value
      Returns:
        between predicate

    - #### gt

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

      Create a predicate for testing whether the first argument is greater than the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        greater-than predicate

    - #### gt

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

      Create a predicate for testing whether the first argument is greater than the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        greater-than predicate

    - #### ge

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

      Create a predicate for testing whether the first argument is greater than or equal to the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        greater-than-or-equal predicate

    - #### ge

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

      Create a predicate for testing whether the first argument is greater than or equal to the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        greater-than-or-equal predicate

    - #### lt

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

      Create a predicate for testing whether the first argument is less than the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        less-than predicate

    - #### lt

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

      Create a predicate for testing whether the first argument is less than the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        less-than predicate

    - #### le

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

      Create a predicate for testing whether the first argument is less than or equal to the second.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        less-than-or-equal predicate

    - #### le

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

      Create a predicate for testing whether the first argument is less than or equal to the second.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        less-than-or-equal predicate

    - #### neg

          <N extends Number> Expression<N> neg(Expression<N> x)

      Create an expression that returns the arithmetic negation of its argument.
      Parameters:
        `x` - expression
      Returns:
        arithmetic negation

    - #### abs

          <N extends Number> Expression<N> abs(Expression<N> x)

      Create an expression that returns the absolute value of its argument.
      Parameters:
        `x` - expression
      Returns:
        absolute value

    - #### sum

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

      Create an expression that returns the sum of its arguments.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        sum

    - #### sum

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

      Create an expression that returns the sum of its arguments.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        sum

    - #### sum

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

      Create an expression that returns the sum of its arguments.
      Parameters:
        `x` - value
        `y` - expression
      Returns:
        sum

    - #### prod

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

      Create an expression that returns the product of its arguments.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        product

    - #### prod

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

      Create an expression that returns the product of its arguments.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        product

    - #### prod

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

      Create an expression that returns the product of its arguments.
      Parameters:
        `x` - value
        `y` - expression
      Returns:
        product

    - #### diff

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

      Create an expression that returns the difference between its arguments.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        difference

    - #### diff

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

      Create an expression that returns the difference between its arguments.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        difference

    - #### diff

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

      Create an expression that returns the difference between its arguments.
      Parameters:
        `x` - value
        `y` - expression
      Returns:
        difference

    - #### quot

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

      Create an expression that returns the quotient of its arguments.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        quotient

    - #### quot

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

      Create an expression that returns the quotient of its arguments.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        quotient

    - #### quot

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

      Create an expression that returns the quotient of its arguments.
      Parameters:
        `x` - value
        `y` - expression
      Returns:
        quotient

    - #### mod

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

      Create an expression that returns the modulus of its arguments.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        modulus

    - #### mod

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

      Create an expression that returns the modulus of its arguments.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        modulus

    - #### mod

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

      Create an expression that returns the modulus of its arguments.
      Parameters:
        `x` - value
        `y` - expression
      Returns:
        modulus

    - #### sqrt

          Expression<Double> sqrt(Expression<? extends Number> x)

      Create an expression that returns the square root of its argument.
      Parameters:
        `x` - expression
      Returns:
        square root

    - #### toLong

          Expression<Long> toLong(Expression<? extends Number> number)

      Typecast. Returns same expression object.
      Parameters:
        `number` - numeric expression
      Returns:
        Expression<Long>

    - #### toInteger

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

      Typecast. Returns same expression object.
      Parameters:
        `number` - numeric expression
      Returns:
        Expression<Integer>

    - #### toFloat

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

      Typecast. Returns same expression object.
      Parameters:
        `number` - numeric expression
      Returns:
        Expression<Float>

    - #### toDouble

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

      Typecast. Returns same expression object.
      Parameters:
        `number` - numeric expression
      Returns:
        Expression<Double>

    - #### toBigDecimal

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

      Typecast. Returns same expression object.
      Parameters:
        `number` - numeric expression
      Returns:
        Expression<BigDecimal>

    - #### toBigInteger

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

      Typecast. Returns same expression object.
      Parameters:
        `number` - numeric expression
      Returns:
        Expression<BigInteger>

    - #### toString

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

      Typecast. Returns same expression object.
      Parameters:
        `character` - expression
      Returns:
        Expression<String>

    - #### literal

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

      Create an expression for a literal.
      Parameters:
        `value` - value represented by the expression
      Returns:
        expression literal
      Throws:
        `IllegalArgumentException` - if value is null

    - #### nullLiteral

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

      Create an expression for a null literal with the given type.
      Parameters:
        `resultClass` - type of the null literal
      Returns:
        null expression literal

    - #### parameter

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

      Create a parameter expression.
      Parameters:
        `paramClass` - parameter class
      Returns:
        parameter expression

    - #### parameter

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

      Create a parameter expression with the given name.
      Parameters:
        `paramClass` - parameter class
        `name` - name that can be used to refer to the parameter
      Returns:
        parameter expression

    - #### isEmpty

          <C extends Collection<?>> Predicate isEmpty(Expression<C> collection)

      Create a predicate that tests whether a collection is empty.
      Parameters:
        `collection` - expression
      Returns:
        is-empty predicate

    - #### isNotEmpty

          <C extends Collection<?>> Predicate isNotEmpty(Expression<C> collection)

      Create a predicate that tests whether a collection is not empty.
      Parameters:
        `collection` - expression
      Returns:
        is-not-empty predicate

    - #### size

          <C extends Collection<?>> Expression<Integer> size(Expression<C> collection)

      Create an expression that tests the size of a collection.
      Parameters:
        `collection` - expression
      Returns:
        size expression

    - #### size

          <C extends Collection<?>> Expression<Integer> size(C collection)

      Create an expression that tests the size of a collection.
      Parameters:
        `collection` - collection
      Returns:
        size expression

    - #### isMember

          <E,C extends Collection<E>> Predicate isMember(Expression<E> elem,
                                                       Expression<C> collection)

      Create a predicate that tests whether an element is a member of a collection. If the collection is empty, the predicate will be false.
      Parameters:
        `elem` - element expression
        `collection` - expression
      Returns:
        is-member predicate

    - #### isMember

          <E,C extends Collection<E>> Predicate isMember(E elem,
                                                       Expression<C> collection)

      Create a predicate that tests whether an element is a member of a collection. If the collection is empty, the predicate will be false.
      Parameters:
        `elem` - element
        `collection` - expression
      Returns:
        is-member predicate

    - #### isNotMember

          <E,C extends Collection<E>> Predicate isNotMember(Expression<E> elem,
                                                          Expression<C> collection)

      Create a predicate that tests whether an element is not a member of a collection. If the collection is empty, the predicate will be true.
      Parameters:
        `elem` - element expression
        `collection` - expression
      Returns:
        is-not-member predicate

    - #### isNotMember

          <E,C extends Collection<E>> Predicate isNotMember(E elem,
                                                          Expression<C> collection)

      Create a predicate that tests whether an element is not a member of a collection. If the collection is empty, the predicate will be true.
      Parameters:
        `elem` - element
        `collection` - expression
      Returns:
        is-not-member predicate

    - #### values

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

      Create an expression that returns the values of a map.
      Parameters:
        `map` - map
      Returns:
        collection expression

    - #### keys

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

      Create an expression that returns the keys of a map.
      Parameters:
        `map` - map
      Returns:
        set expression

    - #### like

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

      Create a predicate for testing whether the expression satisfies the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string expression
      Returns:
        like predicate

    - #### like

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

      Create a predicate for testing whether the expression satisfies the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string
      Returns:
        like predicate

    - #### like

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

      Create a predicate for testing whether the expression satisfies the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string expression
        `escapeChar` - escape character expression
      Returns:
        like predicate

    - #### like

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

      Create a predicate for testing whether the expression satisfies the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string expression
        `escapeChar` - escape character
      Returns:
        like predicate

    - #### like

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

      Create a predicate for testing whether the expression satisfies the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string
        `escapeChar` - escape character expression
      Returns:
        like predicate

    - #### like

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

      Create a predicate for testing whether the expression satisfies the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string
        `escapeChar` - escape character
      Returns:
        like predicate

    - #### notLike

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

      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string expression
      Returns:
        not-like predicate

    - #### notLike

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

      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string
      Returns:
        not-like predicate

    - #### notLike

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

      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string expression
        `escapeChar` - escape character expression
      Returns:
        not-like predicate

    - #### notLike

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

      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string expression
        `escapeChar` - escape character
      Returns:
        not-like predicate

    - #### notLike

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

      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string
        `escapeChar` - escape character expression
      Returns:
        not-like predicate

    - #### notLike

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

      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Parameters:
        `x` - string expression
        `pattern` - string
        `escapeChar` - escape character
      Returns:
        not-like predicate

    - #### concat

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

      Create an expression for string concatenation.
      Parameters:
        `x` - string expression
        `y` - string expression
      Returns:
        expression corresponding to concatenation

    - #### concat

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

      Create an expression for string concatenation.
      Parameters:
        `x` - string expression
        `y` - string
      Returns:
        expression corresponding to concatenation

    - #### concat

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

      Create an expression for string concatenation.
      Parameters:
        `x` - string
        `y` - string expression
      Returns:
        expression corresponding to concatenation

    - #### substring

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

      Create an expression for substring extraction. Extracts a substring starting at the specified position through to end of the string. First position is 1.
      Parameters:
        `x` - string expression
        `from` - start position expression
      Returns:
        expression corresponding to substring extraction

    - #### substring

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

      Create an expression for substring extraction. Extracts a substring starting at the specified position through to end of the string. First position is 1.
      Parameters:
        `x` - string expression
        `from` - start position
      Returns:
        expression corresponding to substring extraction

    - #### substring

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

      Create an expression for substring extraction. Extracts a substring of given length starting at the specified position. First position is 1.
      Parameters:
        `x` - string expression
        `from` - start position expression
        `len` - length expression
      Returns:
        expression corresponding to substring extraction

    - #### substring

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

      Create an expression for substring extraction. Extracts a substring of given length starting at the specified position. First position is 1.
      Parameters:
        `x` - string expression
        `from` - start position
        `len` - length
      Returns:
        expression corresponding to substring extraction

    - #### trim

          Expression<String> trim(Expression<String> x)

      Create expression to trim blanks from both ends of a string.
      Parameters:
        `x` - expression for string to trim
      Returns:
        trim expression

    - #### trim

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

      Create expression to trim blanks from a string.
      Parameters:
        `ts` - trim specification
        `x` - expression for string to trim
      Returns:
        trim expression

    - #### trim

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

      Create expression to trim character from both ends of a string.
      Parameters:
        `t` - expression for character to be trimmed
        `x` - expression for string to trim
      Returns:
        trim expression

    - #### trim

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

      Create expression to trim character from a string.
      Parameters:
        `ts` - trim specification
        `t` - expression for character to be trimmed
        `x` - expression for string to trim
      Returns:
        trim expression

    - #### trim

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

      Create expression to trim character from both ends of a string.
      Parameters:
        `t` - character to be trimmed
        `x` - expression for string to trim
      Returns:
        trim expression

    - #### trim

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

      Create expression to trim character from a string.
      Parameters:
        `ts` - trim specification
        `t` - character to be trimmed
        `x` - expression for string to trim
      Returns:
        trim expression

    - #### lower

          Expression<String> lower(Expression<String> x)

      Create expression for converting a string to lowercase.
      Parameters:
        `x` - string expression
      Returns:
        expression to convert to lowercase

    - #### upper

          Expression<String> upper(Expression<String> x)

      Create expression for converting a string to uppercase.
      Parameters:
        `x` - string expression
      Returns:
        expression to convert to uppercase

    - #### length

          Expression<Integer> length(Expression<String> x)

      Create expression to return length of a string.
      Parameters:
        `x` - string expression
      Returns:
        length expression

    - #### locate

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

      Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
      Parameters:
        `x` - expression for string to be searched
        `pattern` - expression for string to be located
      Returns:
        expression corresponding to position

    - #### locate

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

      Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
      Parameters:
        `x` - expression for string to be searched
        `pattern` - string to be located
      Returns:
        expression corresponding to position

    - #### locate

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

      Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
      Parameters:
        `x` - expression for string to be searched
        `pattern` - expression for string to be located
        `from` - expression for position at which to start search
      Returns:
        expression corresponding to position

    - #### locate

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

      Create expression to locate the position of one string within another, returning position of first character if found. The first position in a string is denoted by 1. If the string to be located is not found, 0 is returned.
      Parameters:
        `x` - expression for string to be searched
        `pattern` - string to be located
        `from` - position at which to start search
      Returns:
        expression corresponding to position

    - #### currentDate

          Expression<Date> currentDate()

      Create expression to return current date.
      Returns:
        expression for current date

    - #### currentTimestamp

          Expression<Timestamp> currentTimestamp()

      Create expression to return current timestamp.
      Returns:
        expression for current timestamp

    - #### currentTime

          Expression<Time> currentTime()

      Create expression to return current time.
      Returns:
        expression for current time

    - #### in

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

      Create predicate to test whether given expression is contained in a list of values.
      Parameters:
        `expression` - to be tested against list of values
      Returns:
        in predicate

    - #### coalesce

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

      Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        coalesce expression

    - #### coalesce

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

      Create an expression that returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        coalesce expression

    - #### nullif

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

      Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.
      Parameters:
        `x` - expression
        `y` - expression
      Returns:
        nullif expression

    - #### nullif

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

      Create an expression that tests whether its argument are equal, returning null if they are and the value of the first expression if they are not.
      Parameters:
        `x` - expression
        `y` - value
      Returns:
        nullif expression

    - #### coalesce

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

      Create a coalesce expression.
      Returns:
        coalesce expression

    - #### selectCase

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

      Create a simple case expression.
      Parameters:
        `expression` - to be tested against the case conditions
      Returns:
        simple case expression

    - #### selectCase

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

      Create a general case expression.
      Returns:
        general case expression

    - #### function

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

      Create an expression for the execution of a database function.
      Parameters:
        `name` - function name
        `type` - expected result type
        `args` - function arguments
      Returns:
        expression

    - #### treat

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

      Downcast Join object to the specified type.
      Parameters:
        `join` - Join object
        `type` - type to be downcast to
      Returns:
        Join object of the specified type
      Since:
        Java Persistence 2.1

    - #### treat

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

      Downcast CollectionJoin object to the specified type.
      Parameters:
        `join` - CollectionJoin object
        `type` - type to be downcast to
      Returns:
        CollectionJoin object of the specified type
      Since:
        Java Persistence 2.1

    - #### treat

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

      Downcast SetJoin object to the specified type.
      Parameters:
        `join` - SetJoin object
        `type` - type to be downcast to
      Returns:
        SetJoin object of the specified type
      Since:
        Java Persistence 2.1

    - #### treat

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

      Downcast ListJoin object to the specified type.
      Parameters:
        `join` - ListJoin object
        `type` - type to be downcast to
      Returns:
        ListJoin object of the specified type
      Since:
        Java Persistence 2.1

    - #### treat

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

      Downcast MapJoin object to the specified type.
      Parameters:
        `join` - MapJoin object
        `type` - type to be downcast to
      Returns:
        MapJoin object of the specified type
      Since:
        Java Persistence 2.1

    - #### treat

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

      Downcast Path object to the specified type.
      Parameters:
        `path` - path
        `type` - type to be downcast to
      Returns:
        Path object of the specified type
      Since:
        Java Persistence 2.1

    - #### treat

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

      Downcast Root object to the specified type.
      Parameters:
        `root` - root
        `type` - type to be downcast to
      Returns:
        Root object of the specified type
      Since:
        Java Persistence 2.1

Copyright © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.