2000余“动批”商户白沟重获新生 - 尼哈乡新闻网

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

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
`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





<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(Expression<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(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.

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, Expression<?> y)
Create a predicate for testing the arguments for equality.

Predicate equal(Expression<?> x, java.lang.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(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, Expression<? extends 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, 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, Expression<? extends 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, 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, Expression<? extends 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, 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, 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.

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.





<T> Expression<T>

literal(T value)
Create an expression for a literal.

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.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.String> lower(Expression<java.lang.String> x)
Create expression for converting a string to lowercase.

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.

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.





<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(Expression<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(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, Expression<?> y)
Create a predicate for testing the arguments for inequality.

Predicate notEqual(Expression<?> x, java.lang.Object y)
Create a predicate for testing the arguments for inequality.

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.

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.





<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(Expression<? extends 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(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, 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.

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.





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

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

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:: 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<java.lang.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 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