Package javax.persistence.criteria

Interface CriteriaBuilder

  • All Known Subinterfaces:
    JpaCriteriaBuilder
    public interface CriteriaBuilder
    Used to construct criteria queries, compound selections, expressions, predicates, orderings.

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

    Since:
    2.0

    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      <N extends java.lang.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<java.lang.Boolean> x, Expression<java.lang.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<java.lang.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 java.lang.Number>
      Expression<java.lang.Double>      		 avg​(Expression<N> x)
      Create an aggregate expression applying the avg operation.
      <Y extends java.lang.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 java.lang.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<java.lang.String> concat​(java.lang.String x, Expression<java.lang.String> y)
      Create an expression for string concatenation.
      Expression<java.lang.String> concat​(Expression<java.lang.String> x, java.lang.String y)
      Create an expression for string concatenation.
      Expression<java.lang.String> concat​(Expression<java.lang.String> x, Expression<java.lang.String> y)
      Create an expression for string concatenation.
      Predicate conjunction()
      Create a conjunction (with zero conjuncts).
      <Y> CompoundSelection<Y> construct​(java.lang.Class<Y> resultClass, Selection<?>... selections)
      Create a selection item corresponding to a constructor.
      Expression<java.lang.Long> count​(Expression<?> x)
      Create an aggregate expression applying the count operation.
      Expression<java.lang.Long> countDistinct​(Expression<?> x)
      Create an aggregate expression applying the count distinct operation.
      <T> CriteriaDelete<T> createCriteriaDelete​(java.lang.Class<T> targetEntity)
      Create a CriteriaDelete query object to perform a bulk delete operation.
      <T> CriteriaUpdate<T> createCriteriaUpdate​(java.lang.Class<T> targetEntity)
      Create a CriteriaUpdate query object to perform a bulk update operation.
      CriteriaQuery<java.lang.Object> createQuery()
      Create a CriteriaQuery object.
      <T> CriteriaQuery<T> createQuery​(java.lang.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<java.sql.Date> currentDate()
      Create expression to return current date.
      Expression<java.sql.Time> currentTime()
      Create expression to return current time.
      Expression<java.sql.Timestamp> currentTimestamp()
      Create expression to return current timestamp.
      Order desc​(Expression<?> x)
      Create an ordering by the descending value of the expression.
      <N extends java.lang.Number>
      Expression<N>      		 diff​(Expression<? extends N> x, Expression<? extends N> y)
      Create an expression that returns the difference between its arguments.
      <N extends java.lang.Number>
      Expression<N>      		 diff​(Expression<? extends N> x, N y)
      Create an expression that returns the difference between its arguments.
      <N extends java.lang.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, java.lang.Object y)
      Create a predicate for testing the arguments for equality.
      Predicate equal​(Expression<?> x, Expression<?> 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​(java.lang.String name, java.lang.Class<T> type, Expression<?>... args)
      Create an expression for the execution of a database function.
      Predicate ge​(Expression<? extends java.lang.Number> x, java.lang.Number y)
      Create a predicate for testing whether the first argument is greater than or equal to the second.
      Predicate ge​(Expression<? extends java.lang.Number> x, Expression<? extends java.lang.Number> y)
      Create a predicate for testing whether the first argument is greater than or equal to the second.
      <Y extends java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.Number> x, java.lang.Number y)
      Create a predicate for testing whether the first argument is greater than the second.
      Predicate gt​(Expression<? extends java.lang.Number> x, Expression<? extends java.lang.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 java.util.Collection<?>>
      Predicate      		 isEmpty​(Expression<C> collection)
      Create a predicate that tests whether a collection is empty.
      Predicate isFalse​(Expression<java.lang.Boolean> x)
      Create a predicate testing for a false value.
      <E,​C extends java.util.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 java.util.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 java.util.Collection<?>>
      Predicate      		 isNotEmpty​(Expression<C> collection)
      Create a predicate that tests whether a collection is not empty.
      <E,​C extends java.util.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 java.util.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<java.lang.Boolean> x)
      Create a predicate testing for a true value.
      <K,​M extends java.util.Map<K,​?>>
      Expression<java.util.Set<K>>      		 keys​(M map)
      Create an expression that returns the keys of a map.
      Predicate le​(Expression<? extends java.lang.Number> x, java.lang.Number y)
      Create a predicate for testing whether the first argument is less than or equal to the second.
      Predicate le​(Expression<? extends java.lang.Number> x, Expression<? extends java.lang.Number> y)
      Create a predicate for testing whether the first argument is less than or equal to the second.
      <X extends java.lang.Comparable<? super X>>
      Expression<X>      		 least​(Expression<X> x)
      Create an aggregate expression for finding the least of the values (strings, dates, etc).
      Expression<java.lang.Integer> length​(Expression<java.lang.String> x)
      Create expression to return length of a string.
      <Y extends java.lang.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 java.lang.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 java.lang.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 java.lang.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<java.lang.String> x, java.lang.String pattern)
      Create a predicate for testing whether the expression satisfies the given pattern.
      Predicate like​(Expression<java.lang.String> x, java.lang.String pattern, char escapeChar)
      Create a predicate for testing whether the expression satisfies the given pattern.
      Predicate like​(Expression<java.lang.String> x, java.lang.String pattern, Expression<java.lang.Character> escapeChar)
      Create a predicate for testing whether the expression satisfies the given pattern.
      Predicate like​(Expression<java.lang.String> x, Expression<java.lang.String> pattern)
      Create a predicate for testing whether the expression satisfies the given pattern.
      Predicate like​(Expression<java.lang.String> x, Expression<java.lang.String> pattern, char escapeChar)
      Create a predicate for testing whether the expression satisfies the given pattern.
      Predicate like​(Expression<java.lang.String> x, Expression<java.lang.String> pattern, Expression<java.lang.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<java.lang.Integer> locate​(Expression<java.lang.String> x, java.lang.String pattern)
      Create expression to locate the position of one string within another, returning position of first character if found.
      Expression<java.lang.Integer> locate​(Expression<java.lang.String> x, java.lang.String pattern, int from)
      Create expression to locate the position of one string within another, returning position of first character if found.
      Expression<java.lang.Integer> locate​(Expression<java.lang.String> x, Expression<java.lang.String> pattern)
      Create expression to locate the position of one string within another, returning position of first character if found.
      Expression<java.lang.Integer> locate​(Expression<java.lang.String> x, Expression<java.lang.String> pattern, Expression<java.lang.Integer> from)
      Create expression to locate the position of one string within another, returning position of first character if found.
      Expression<java.lang.String> lower​(Expression<java.lang.String> x)
      Create expression for converting a string to lowercase.
      Predicate lt​(Expression<? extends java.lang.Number> x, java.lang.Number y)
      Create a predicate for testing whether the first argument is less than the second.
      Predicate lt​(Expression<? extends java.lang.Number> x, Expression<? extends java.lang.Number> y)
      Create a predicate for testing whether the first argument is less than the second.
      <N extends java.lang.Number>
      Expression<N>      		 max​(Expression<N> x)
      Create an aggregate expression applying the numerical max operation.
      <N extends java.lang.Number>
      Expression<N>      		 min​(Expression<N> x)
      Create an aggregate expression applying the numerical min operation.
      Expression<java.lang.Integer> mod​(java.lang.Integer x, Expression<java.lang.Integer> y)
      Create an expression that returns the modulus of its arguments.
      Expression<java.lang.Integer> mod​(Expression<java.lang.Integer> x, java.lang.Integer y)
      Create an expression that returns the modulus of its arguments.
      Expression<java.lang.Integer> mod​(Expression<java.lang.Integer> x, Expression<java.lang.Integer> y)
      Create an expression that returns the modulus of its arguments.
      <N extends java.lang.Number>
      Expression<N>      		 neg​(Expression<N> x)
      Create an expression that returns the arithmetic negation of its argument.
      Predicate not​(Expression<java.lang.Boolean> restriction)
      Create a negation of the given restriction.
      Predicate notEqual​(Expression<?> x, java.lang.Object y)
      Create a predicate for testing the arguments for inequality.
      Predicate notEqual​(Expression<?> x, Expression<?> y)
      Create a predicate for testing the arguments for inequality.
      Predicate notLike​(Expression<java.lang.String> x, java.lang.String pattern)
      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Predicate notLike​(Expression<java.lang.String> x, java.lang.String pattern, char escapeChar)
      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Predicate notLike​(Expression<java.lang.String> x, java.lang.String pattern, Expression<java.lang.Character> escapeChar)
      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Predicate notLike​(Expression<java.lang.String> x, Expression<java.lang.String> pattern)
      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Predicate notLike​(Expression<java.lang.String> x, Expression<java.lang.String> pattern, char escapeChar)
      Create a predicate for testing whether the expression does not satisfy the given pattern.
      Predicate notLike​(Expression<java.lang.String> x, Expression<java.lang.String> pattern, Expression<java.lang.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​(java.lang.Class<T> resultClass)
      Create an expression for a null literal with the given type.
      Predicate or​(Expression<java.lang.Boolean> x, Expression<java.lang.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​(java.lang.Class<T> paramClass)
      Create a parameter expression.
      <T> ParameterExpression<T> parameter​(java.lang.Class<T> paramClass, java.lang.String name)
      Create a parameter expression with the given name.
      <N extends java.lang.Number>
      Expression<N>      		 prod​(Expression<? extends N> x, Expression<? extends N> y)
      Create an expression that returns the product of its arguments.
      <N extends java.lang.Number>
      Expression<N>      		 prod​(Expression<? extends N> x, N y)
      Create an expression that returns the product of its arguments.
      <N extends java.lang.Number>
      Expression<N>      		 prod​(N x, Expression<? extends N> y)
      Create an expression that returns the product of its arguments.
      Expression<java.lang.Number> quot​(java.lang.Number x, Expression<? extends java.lang.Number> y)
      Create an expression that returns the quotient of its arguments.
      Expression<java.lang.Number> quot​(Expression<? extends java.lang.Number> x, java.lang.Number y)
      Create an expression that returns the quotient of its arguments.
      Expression<java.lang.Number> quot​(Expression<? extends java.lang.Number> x, Expression<? extends java.lang.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 java.util.Collection<?>>
      Expression<java.lang.Integer>      		 size​(C collection)
      Create an expression that tests the size of a collection.
      <C extends java.util.Collection<?>>
      Expression<java.lang.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<java.lang.Double> sqrt​(Expression<? extends java.lang.Number> x)
      Create an expression that returns the square root of its argument.
      Expression<java.lang.String> substring​(Expression<java.lang.String> x, int from)
      Create an expression for substring extraction.
      Expression<java.lang.String> substring​(Expression<java.lang.String> x, int from, int len)
      Create an expression for substring extraction.
      Expression<java.lang.String> substring​(Expression<java.lang.String> x, Expression<java.lang.Integer> from)
      Create an expression for substring extraction.
      Expression<java.lang.String> substring​(Expression<java.lang.String> x, Expression<java.lang.Integer> from, Expression<java.lang.Integer> len)
      Create an expression for substring extraction.
      <N extends java.lang.Number>
      Expression<N>      		 sum​(Expression<? extends N> x, Expression<? extends N> y)
      Create an expression that returns the sum of its arguments.
      <N extends java.lang.Number>
      Expression<N>      		 sum​(Expression<? extends N> x, N y)
      Create an expression that returns the sum of its arguments.
      <N extends java.lang.Number>
      Expression<N>      		 sum​(Expression<N> x)
      Create an aggregate expression applying the sum operation.
      <N extends java.lang.Number>
      Expression<N>      		 sum​(N x, Expression<? extends N> y)
      Create an expression that returns the sum of its arguments.
      Expression<java.lang.Double> sumAsDouble​(Expression<java.lang.Float> x)
      Create an aggregate expression applying the sum operation to a Float-valued expression, returning a Double result.
      Expression<java.lang.Long> sumAsLong​(Expression<java.lang.Integer> x)
      Create an aggregate expression applying the sum operation to an Integer-valued expression, returning a Long result.
      Expression<java.math.BigDecimal> toBigDecimal​(Expression<? extends java.lang.Number> number)
      Typecast.
      Expression<java.math.BigInteger> toBigInteger​(Expression<? extends java.lang.Number> number)
      Typecast.
      Expression<java.lang.Double> toDouble​(Expression<? extends java.lang.Number> number)
      Typecast.
      Expression<java.lang.Float> toFloat​(Expression<? extends java.lang.Number> number)
      Typecast.
      Expression<java.lang.Integer> toInteger​(Expression<? extends java.lang.Number> number)
      Typecast.
      Expression<java.lang.Long> toLong​(Expression<? extends java.lang.Number> number)
      Typecast.
      Expression<java.lang.String> toString​(Expression<java.lang.Character> character)
      Typecast.
      <X,​T,​E extends T>
      CollectionJoin<X,​E>      		 treat​(CollectionJoin<X,​T> join, java.lang.Class<E> type)
      Downcast CollectionJoin object to the specified type.
      <X,​T,​V extends T>
      Join<X,​V>      		 treat​(Join<X,​T> join, java.lang.Class<V> type)
      Downcast Join object to the specified type.
      <X,​T,​E extends T>
      ListJoin<X,​E>      		 treat​(ListJoin<X,​T> join, java.lang.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, java.lang.Class<V> type)
      Downcast MapJoin object to the specified type.
      <X,​T extends X>
      Path<T>      		 treat​(Path<X> path, java.lang.Class<T> type)
      Downcast Path object to the specified type.
      <X,​T extends X>
      Root<T>      		 treat​(Root<X> root, java.lang.Class<T> type)
      Downcast Root object to the specified type.
      <X,​T,​E extends T>
      SetJoin<X,​E>      		 treat​(SetJoin<X,​T> join, java.lang.Class<E> type)
      Downcast SetJoin object to the specified type.
      Expression<java.lang.String> trim​(char t, Expression<java.lang.String> x)
      Create expression to trim character from both ends of a string.
      Expression<java.lang.String> trim​(CriteriaBuilder.Trimspec ts, char t, Expression<java.lang.String> x)
      Create expression to trim character from a string.
      Expression<java.lang.String> trim​(CriteriaBuilder.Trimspec ts, Expression<java.lang.Character> t, Expression<java.lang.String> x)
      Create expression to trim character from a string.
      Expression<java.lang.String> trim​(CriteriaBuilder.Trimspec ts, Expression<java.lang.String> x)
      Create expression to trim blanks from a string.
      Expression<java.lang.String> trim​(Expression<java.lang.Character> t, Expression<java.lang.String> x)
      Create expression to trim character from both ends of a string.
      Expression<java.lang.String> trim​(Expression<java.lang.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<java.lang.String> upper​(Expression<java.lang.String> x)
      Create expression for converting a string to uppercase.
      <V,​M extends java.util.Map<?,​V>>
      Expression<java.util.Collection<V>>      		 values​(M map)
      Create an expression that returns the values of a map.

    • Method Detail

      • createQuery

        CriteriaQuery<java.lang.Object> createQuery()
        Create a CriteriaQuery object.
        Returns:
        criteria query object

      • createQuery

        <T> CriteriaQuery<T> createQuery​(java.lang.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​(java.lang.Class<T> targetEntity)
        Create a CriteriaUpdate query object to perform a bulk update operation.
        Parameters:
        targetEntity - target type for update operation
        Returns:
        the query object
        Since:
        2.1

      • createCriteriaDelete

        <T> CriteriaDelete<T> createCriteriaDelete​(java.lang.Class<T> targetEntity)
        Create a CriteriaDelete query object to perform a bulk delete operation.
        Parameters:
        targetEntity - target type for delete operation
        Returns:
        the query object
        Since:
        2.1

      • construct

        <Y> CompoundSelection<Y> construct​(java.lang.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:
        java.lang.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:
        java.lang.IllegalArgumentException - if an argument is a tuple- or array-valued selection item

      • array

        CompoundSelection<java.lang.Object[]> array​(Selection<?>... selections)
        Create an array-valued selection item.
        Parameters:
        selections - selection items
        Returns:
        array-valued compound selection
        Throws:
        java.lang.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 java.lang.Number> Expression<java.lang.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 java.lang.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<java.lang.Long> sumAsLong​(Expression<java.lang.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<java.lang.Double> sumAsDouble​(Expression<java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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<java.lang.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<java.lang.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<java.lang.Boolean> x,
              Expression<java.lang.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<java.lang.Boolean> x,
             Expression<java.lang.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<java.lang.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<java.lang.Boolean> x)
        Create a predicate testing for a true value.
        Parameters:
        x - expression to be tested
        Returns:
        predicate

      • isFalse

        Predicate isFalse​(Expression<java.lang.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,
                java.lang.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,
                   java.lang.Object y)
        Create a predicate for testing the arguments for inequality.
        Parameters:
        x - expression
        y - object
        Returns:
        inequality predicate

      • greaterThan

        <Y extends java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.Number> x,
             Expression<? extends java.lang.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 java.lang.Number> x,
             java.lang.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 java.lang.Number> x,
             Expression<? extends java.lang.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 java.lang.Number> x,
             java.lang.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 java.lang.Number> x,
             Expression<? extends java.lang.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 java.lang.Number> x,
             java.lang.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 java.lang.Number> x,
             Expression<? extends java.lang.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 java.lang.Number> x,
             java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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<java.lang.Number> quot​(Expression<? extends java.lang.Number> x,
                                  Expression<? extends java.lang.Number> y)
        Create an expression that returns the quotient of its arguments.
        Parameters:
        x - expression
        y - expression
        Returns:
        quotient

      • quot

        Expression<java.lang.Number> quot​(Expression<? extends java.lang.Number> x,
                                  java.lang.Number y)
        Create an expression that returns the quotient of its arguments.
        Parameters:
        x - expression
        y - value
        Returns:
        quotient

      • quot

        Expression<java.lang.Number> quot​(java.lang.Number x,
                                  Expression<? extends java.lang.Number> y)
        Create an expression that returns the quotient of its arguments.
        Parameters:
        x - value
        y - expression
        Returns:
        quotient

      • mod

        Expression<java.lang.Integer> mod​(Expression<java.lang.Integer> x,
                                  Expression<java.lang.Integer> y)
        Create an expression that returns the modulus of its arguments.
        Parameters:
        x - expression
        y - expression
        Returns:
        modulus

      • mod

        Expression<java.lang.Integer> mod​(Expression<java.lang.Integer> x,
                                  java.lang.Integer y)
        Create an expression that returns the modulus of its arguments.
        Parameters:
        x - expression
        y - value
        Returns:
        modulus

      • mod

        Expression<java.lang.Integer> mod​(java.lang.Integer x,
                                  Expression<java.lang.Integer> y)
        Create an expression that returns the modulus of its arguments.
        Parameters:
        x - value
        y - expression
        Returns:
        modulus

      • sqrt

        Expression<java.lang.Double> sqrt​(Expression<? extends java.lang.Number> x)
        Create an expression that returns the square root of its argument.
        Parameters:
        x - expression
        Returns:
        square root

      • toLong

        Expression<java.lang.Long> toLong​(Expression<? extends java.lang.Number> number)
        Typecast. Returns same expression object.
        Parameters:
        number - numeric expression
        Returns:
        Expression<Long>

      • toInteger

        Expression<java.lang.Integer> toInteger​(Expression<? extends java.lang.Number> number)
        Typecast. Returns same expression object.
        Parameters:
        number - numeric expression
        Returns:
        Expression<Integer>

      • toFloat

        Expression<java.lang.Float> toFloat​(Expression<? extends java.lang.Number> number)
        Typecast. Returns same expression object.
        Parameters:
        number - numeric expression
        Returns:
        Expression<Float>

      • toDouble

        Expression<java.lang.Double> toDouble​(Expression<? extends java.lang.Number> number)
        Typecast. Returns same expression object.
        Parameters:
        number - numeric expression
        Returns:
        Expression<Double>

      • toBigDecimal

        Expression<java.math.BigDecimal> toBigDecimal​(Expression<? extends java.lang.Number> number)
        Typecast. Returns same expression object.
        Parameters:
        number - numeric expression
        Returns:
        Expression<BigDecimal>

      • toBigInteger

        Expression<java.math.BigInteger> toBigInteger​(Expression<? extends java.lang.Number> number)
        Typecast. Returns same expression object.
        Parameters:
        number - numeric expression
        Returns:
        Expression<BigInteger>

      • toString

        Expression<java.lang.String> toString​(Expression<java.lang.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:
        java.lang.IllegalArgumentException - if value is null

      • nullLiteral

        <T> Expression<T> nullLiteral​(java.lang.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​(java.lang.Class<T> paramClass)
        Create a parameter expression.
        Parameters:
        paramClass - parameter class
        Returns:
        parameter expression

      • parameter

        <T> ParameterExpression<T> parameter​(java.lang.Class<T> paramClass,
                                     java.lang.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 java.util.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 java.util.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 java.util.Collection<?>> Expression<java.lang.Integer> size​(Expression<C> collection)
        Create an expression that tests the size of a collection.
        Parameters:
        collection - expression
        Returns:
        size expression

      • size

        <C extends java.util.Collection<?>> Expression<java.lang.Integer> size​(C collection)
        Create an expression that tests the size of a collection.
        Parameters:
        collection - collection
        Returns:
        size expression

      • isMember

        <E,​C extends java.util.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 java.util.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 java.util.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 java.util.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 java.util.Map<?,​V>> Expression<java.util.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 java.util.Map<K,​?>> Expression<java.util.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<java.lang.String> x,
               Expression<java.lang.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<java.lang.String> x,
               java.lang.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<java.lang.String> x,
               Expression<java.lang.String> pattern,
               Expression<java.lang.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<java.lang.String> x,
               Expression<java.lang.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<java.lang.String> x,
               java.lang.String pattern,
               Expression<java.lang.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<java.lang.String> x,
               java.lang.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<java.lang.String> x,
                  Expression<java.lang.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<java.lang.String> x,
                  java.lang.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<java.lang.String> x,
                  Expression<java.lang.String> pattern,
                  Expression<java.lang.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<java.lang.String> x,
                  Expression<java.lang.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<java.lang.String> x,
                  java.lang.String pattern,
                  Expression<java.lang.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<java.lang.String> x,
                  java.lang.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<java.lang.String> concat​(Expression<java.lang.String> x,
                                    Expression<java.lang.String> y)
        Create an expression for string concatenation.
        Parameters:
        x - string expression
        y - string expression
        Returns:
        expression corresponding to concatenation

      • concat

        Expression<java.lang.String> concat​(Expression<java.lang.String> x,
                                    java.lang.String y)
        Create an expression for string concatenation.
        Parameters:
        x - string expression
        y - string
        Returns:
        expression corresponding to concatenation

      • concat

        Expression<java.lang.String> concat​(java.lang.String x,
                                    Expression<java.lang.String> y)
        Create an expression for string concatenation.
        Parameters:
        x - string
        y - string expression
        Returns:
        expression corresponding to concatenation

      • substring

        Expression<java.lang.String> substring​(Expression<java.lang.String> x,
                                       Expression<java.lang.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<java.lang.String> substring​(Expression<java.lang.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<java.lang.String> substring​(Expression<java.lang.String> x,
                                       Expression<java.lang.Integer> from,
                                       Expression<java.lang.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<java.lang.String> substring​(Expression<java.lang.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<java.lang.String> trim​(Expression<java.lang.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<java.lang.String> trim​(CriteriaBuilder.Trimspec ts,
                                  Expression<java.lang.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<java.lang.String> trim​(Expression<java.lang.Character> t,
                                  Expression<java.lang.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<java.lang.String> trim​(CriteriaBuilder.Trimspec ts,
                                  Expression<java.lang.Character> t,
                                  Expression<java.lang.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<java.lang.String> trim​(char t,
                                  Expression<java.lang.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<java.lang.String> trim​(CriteriaBuilder.Trimspec ts,
                                  char t,
                                  Expression<java.lang.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<java.lang.String> lower​(Expression<java.lang.String> x)
        Create expression for converting a string to lowercase.
        Parameters:
        x - string expression
        Returns:
        expression to convert to lowercase

      • upper

        Expression<java.lang.String> upper​(Expression<java.lang.String> x)
        Create expression for converting a string to uppercase.
        Parameters:
        x - string expression
        Returns:
        expression to convert to uppercase

      • length

        Expression<java.lang.Integer> length​(Expression<java.lang.String> x)
        Create expression to return length of a string.
        Parameters:
        x - string expression
        Returns:
        length expression

      • locate

        Expression<java.lang.Integer> locate​(Expression<java.lang.String> x,
                                     Expression<java.lang.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<java.lang.Integer> locate​(Expression<java.lang.String> x,
                                     java.lang.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<java.lang.Integer> locate​(Expression<java.lang.String> x,
                                     Expression<java.lang.String> pattern,
                                     Expression<java.lang.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<java.lang.Integer> locate​(Expression<java.lang.String> x,
                                     java.lang.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<java.sql.Date> currentDate()
        Create expression to return current date.
        Returns:
        expression for current date

      • currentTimestamp

        Expression<java.sql.Timestamp> currentTimestamp()
        Create expression to return current timestamp.
        Returns:
        expression for current timestamp

      • currentTime

        Expression<java.sql.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

      • 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​(java.lang.String name,
                           java.lang.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,
                                                    java.lang.Class<V> type)
        Downcast Join object to the specified type.
        Parameters:
        join - Join object
        type - type to be downcast to
        Returns:
        Join object of the specified type
        Since:
        2.1

      • treat

        <X,​T,​E extends T> CollectionJoin<X,​E> treat​(CollectionJoin<X,​T> join,
                                                              java.lang.Class<E> type)
        Downcast CollectionJoin object to the specified type.
        Parameters:
        join - CollectionJoin object
        type - type to be downcast to
        Returns:
        CollectionJoin object of the specified type
        Since:
        2.1

      • treat

        <X,​T,​E extends T> SetJoin<X,​E> treat​(SetJoin<X,​T> join,
                                                       java.lang.Class<E> type)
        Downcast SetJoin object to the specified type.
        Parameters:
        join - SetJoin object
        type - type to be downcast to
        Returns:
        SetJoin object of the specified type
        Since:
        2.1

      • treat

        <X,​T,​E extends T> ListJoin<X,​E> treat​(ListJoin<X,​T> join,
                                                        java.lang.Class<E> type)
        Downcast ListJoin object to the specified type.
        Parameters:
        join - ListJoin object
        type - type to be downcast to
        Returns:
        ListJoin object of the specified type
        Since:
        2.1

      • treat

        <X,​K,​T,​V extends T> MapJoin<X,​K,​V> treat​(MapJoin<X,​K,​T> join,
                                                                       java.lang.Class<V> type)
        Downcast MapJoin object to the specified type.
        Parameters:
        join - MapJoin object
        type - type to be downcast to
        Returns:
        MapJoin object of the specified type
        Since:
        2.1

      • treat

        <X,​T extends X> Path<T> treat​(Path<X> path,
                                    java.lang.Class<T> type)
        Downcast Path object to the specified type.
        Parameters:
        path - path
        type - type to be downcast to
        Returns:
        Path object of the specified type
        Since:
        2.1

      • treat

        <X,​T extends X> Root<T> treat​(Root<X> root,
                                    java.lang.Class<T> type)
        Downcast Root object to the specified type.
        Parameters:
        root - root
        type - type to be downcast to
        Returns:
        Root object of the specified type
        Since:
        2.1