Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
javax.persistence.criteria.QueryBuilder Maven / Gradle / Ivy
Hibernate developmental JSR 317 (Java Persistence API 2.0) contracts. Used to
allow incremental implementation of features on the way to full JPA 2.0 support.
// $Id: QueryBuilder.java 17038 2009-07-08 10:58:24Z epbernard $
// EJB3 Specification Copyright 2004-2009 Sun Microsystems, Inc.
package javax.persistence.criteria;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import javax.persistence.Tuple;
/**
* Factory object for queries, select lists, restrictions,
* expressions, orderings
* Note that Predicate is used instead of Expression
* in this API in order to work around the fact that Java
* generics are not compatible with varags.
*/
public interface QueryBuilder {
/**
* Create a Criteria query object.
*
* @return query object
*/
CriteriaQuery createQuery();
/**
* Create a Criteria query object with the specified result
* type.
*
* @param resultClass type of the query result
*
* @return query object
*/
CriteriaQuery createQuery(Class resultClass);
/**
* Create a Criteria query object that returns a tuple of
* objects as its result.
*
* @return query object
*/
CriteriaQuery createTupleQuery();
/**
* Define a selection item corresponding to a constructor.
*
* @param result class whose instance is to be constructed
* @param selections arguments to the constructor
*
* @return compound selection item
*
* @throws IllegalArgumentException if an argument is a tuple- or
* array-valued selection item
*/
CompoundSelection construct(Class result, Selection... selections);
/**
* Define a tuple-valued selection item
*
* @param selections selection items
*
* @return tuple-valued compound selection
*
* @throws IllegalArgumentException if an argument is a tuple- or
* array-valued selection item
*/
CompoundSelection tuple(Selection... selections);
/**
* Define a array-valued selection item
*
* @param selections selection items
*
* @return array-valued compound selection
*
* @throws IllegalArgumentException if an argument is a tuple- or
* array-valued selection item
*/
CompoundSelection array(Selection... selections);
//ordering:
/**
* Create an ordering by the ascending value of the expression.
*
* @param x expression used to define the ordering
*
* @return ascending ordering corresponding to the expression
*/
Order asc(Expression x);
/**
* Create an ordering by the descending value of the expression.
*
* @param x expression used to define the ordering
*
* @return descending ordering corresponding to the expression
*/
Order desc(Expression x);
//aggregate functions:
/**
* Create an expression applying the avg operation.
*
* @param x expression representing input value to avg operation
*
* @return avg expression
*/
Expression avg(Expression x);
/**
* Create an expression applying the sum operation.
*
* @param x expression representing input value to sum operation
*
* @return sum expression
*/
Expression sum(Expression x);
/**
* Create an expression applying the numerical max operation.
*
* @param x expression representing input value to max operation
*
* @return max expression
*/
Expression max(Expression x);
/**
* Create an expression applying the numerical min operation.
*
* @param x expression representing input value to min operation
*
* @return min expression
*/
Expression min(Expression x);
/**
* Create an aggregate expression for finding the greatest of
* the values (strings, dates, etc).
*
* @param x expression representing input value to greatest
* operation
*
* @return greatest expression
*/
> Expression greatest(Expression x);
/**
* Create an aggregate expression for finding the least of
* the values (strings, dates, etc).
*
* @param x expression representing input value to least
* operation
*
* @return least expression
*/
> Expression least(Expression x);
/**
* Create an expression applying the count operation.
*
* @param x expression representing input value to count
* operation
*
* @return count expression
*/
Expression count(Expression x);
/**
* Create an expression applying the count distinct operation.
*
* @param x expression representing input value to
* count distinct operation
*
* @return count distinct expression
*/
Expression countDistinct(Expression x);
//subqueries:
/**
* Create a predicate testing the existence of a subquery result.
*
* @param subquery subquery whose result is to be tested
*
* @return exists predicate
*/
Predicate exists(Subquery subquery);
/**
* Create a predicate corresponding to an all expression over the
* subquery results.
*
* @param subquery
*
* @return all expression
*/
Expression all(Subquery subquery);
/**
* Create a predicate corresponding to a some expression over the
* subquery results. This is equivalent to an any expression.
*
* @param subquery
*
* @return all expression
*/
Expression some(Subquery subquery);
/**
* Create a predicate corresponding to an any expression over the
* subquery results. This is equivalent to a some expression.
*
* @param subquery
*
* @return any expression
*/
Expression any(Subquery subquery);
//boolean functions:
/**
* Create a conjunction of the given boolean expressions.
*
* @param x boolean expression
* @param y boolean expression
*
* @return and predicate
*/
Predicate and(Expression x, Expression y);
/**
* Create a disjunction of the given boolean expressions.
*
* @param x boolean expression
* @param y boolean expression
*
* @return or predicate
*/
Predicate or(Expression x, Expression y);
/**
* Create a conjunction of the given restriction predicates.
* A conjunction of zero predicates is true.
*
* @param restriction zero or more restriction predicates
*
* @return and predicate
*/
Predicate and(Predicate... restrictions);
/**
* Create a conjunction of the given restriction predicates.
* A disjunction of zero predicates is false.
*
* @param restriction zero or more restriction predicates
*
* @return or predicate
*/
Predicate or(Predicate... restrictions);
/**
* Create a negation of the given restriction.
*
* @param restriction restriction expression
*
* @return not predicate
*/
Predicate not(Expression restriction);
/**
* Create a conjunction (with zero conjuncts).
* A conjunction with zero conjuncts is true.
*
* @return and predicate
*/
Predicate conjunction();
/**
* Create a disjunction (with zero disjuncts).
* A disjunction with zero disjuncts is false.
*
* @return or predicate
*/
Predicate disjunction();
//turn Expression into a Predicate
//useful for use with varargs methods
/**
* Create a predicate testing for a true value.
*
* @param x expression to be tested if true
*
* @return predicate
*/
Predicate isTrue(Expression x);
/**
* Create a predicate testing for a false value.
*
* @param x expression to be tested if false
*
* @return predicate
*/
Predicate isFalse(Expression x);
//null tests:
/**
* Create a predicate to test whether the expression is null.
*
* @param x expression
*
* @return predicate
*/
Predicate isNull(Expression x);
/**
* Create a predicate to test whether the expression is not null.
*
* @param x expression
*
* @return predicate
*/
Predicate isNotNull(Expression x);
//equality:
/**
* Create a predicate for testing the arguments for equality.
*
* @param x expression
* @param y expression
*
* @return equality predicate
*/
Predicate equal(Expression x, Expression y);
/**
* Create a predicate for testing the arguments for inequality.
*
* @param x expression
* @param y expression
*
* @return inequality predicate
*/
Predicate notEqual(Expression x, Expression y);
/**
* Create a predicate for testing the arguments for equality.
*
* @param x expression
* @param y object
*
* @return equality predicate
*/
Predicate equal(Expression x, Object y);
/**
* Create a predicate for testing the arguments for inequality.
*
* @param x expression
* @param y object
*
* @return inequality predicate
*/
Predicate notEqual(Expression x, Object y);
//comparisons for generic (non-numeric) operands:
/**
* Create a predicate for testing whether the first argument is
* greater than the second.
*
* @param x expression
* @param y expression
*
* @return greater-than predicate
*/
> Predicate greaterThan(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* less than the second.
*
* @param x expression
* @param y expression
*
* @return less-than predicate
*/
> Predicate lessThan(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* greater than or equal to the second.
*
* @param x expression
* @param y expression
*
* @return greater-than-or-equal predicate
*/
> Predicate greaterThanOrEqualTo(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* less than or equal to the second.
*
* @param x expression
* @param y expression
*
* @return less-than-or-equal predicate
*/
> Predicate lessThanOrEqualTo(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* between the second and third arguments in value.
*
* @param v expression
* @param x expression
* @param y expression
*
* @return between predicate
*/
> Predicate between(Expression v, Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* greater than the second.
*
* @param x expression
* @param y value
*
* @return greater-than predicate
*/
> Predicate greaterThan(Expression x, Y y);
/**
* Create a predicate for testing whether the first argument is
* less than the second.
*
* @param x expression
* @param y value
*
* @return less-than predicate
*/
> Predicate lessThan(Expression x, Y y);
/**
* Create a predicate for testing whether the first argument is
* greater than or equal to the second.
*
* @param x expression
* @param y value
*
* @return greater-than-or-equal predicate
*/
> Predicate greaterThanOrEqualTo(Expression x, Y y);
/**
* Create a predicate for testing whether the first argument is
* less than or equal to the second.
*
* @param x expression
* @param y value
*
* @return less-than-or-equal predicate
*/
> Predicate lessThanOrEqualTo(Expression x, Y y);
/**
* Create a predicate for testing whether the first argument is
* between the second and third arguments in value.
*
* @param v expression
* @param x value
* @param y value
*
* @return between predicate
*/
> Predicate between(Expression v, Y x, Y y);
//comparisons for numeric operands:
/**
* Create a predicate for testing whether the first argument is
* greater than the second.
*
* @param x expression
* @param y expression
*
* @return greater-than predicate
*/
Predicate gt(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* less than the second.
*
* @param x expression
* @param y expression
*
* @return less-than predicate
*/
Predicate lt(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* greater than or equal to the second.
*
* @param x expression
* @param y expression
*
* @return greater-than-or-equal predicate
*/
Predicate ge(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* less than or equal to the second.
*
* @param x expression
* @param y expression
*
* @return less-than-or-equal predicate
*/
Predicate le(Expression x, Expression y);
/**
* Create a predicate for testing whether the first argument is
* greater than the second.
*
* @param x expression
* @param y value
*
* @return greater-than predicate
*/
Predicate gt(Expression x, Number y);
/**
* Create a predicate for testing whether the first argument is
* less than the second.
*
* @param x expression
* @param y value
*
* @return less-than predicate
*/
Predicate lt(Expression x, Number y);
/**
* Create a predicate for testing whether the first argument is
* greater than or equal to the second.
*
* @param x expression
* @param y value
*
* @return greater-than-or-equal predicate
*/
Predicate ge(Expression x, Number y);
/**
* Create a predicate for testing whether the first argument is
* less than or equal to the second.
*
* @param x expression
* @param y value
*
* @return less-than-or-equal predicate
*/
Predicate le(Expression x, Number y);
//numerical operations:
/**
* Create an expression that returns the arithmetic negation
* of its argument.
*
* @param x expression
*
* @return arithmetic negation
*/
Expression neg(Expression x);
/**
* Create an expression that returns the absolute value
* of its argument.
*
* @param x expression
*
* @return absolute value
*/
Expression abs(Expression x);
/**
* Create an expression that returns the sum
* of its arguments.
*
* @param x expression
* @param y expression
*
* @return sum
*/
Expression sum(Expression x, Expression y);
/**
* Create an expression that returns the product
* of its arguments.
*
* @param x expression
* @param y expression
*
* @return product
*/
Expression prod(Expression x, Expression y);
/**
* Create an expression that returns the difference
* between its arguments.
*
* @param x expression
* @param y expression
*
* @return difference
*/
Expression diff(Expression x, Expression y);
/**
* Create an expression that returns the sum
* of its arguments.
*
* @param x expression
* @param y value
*
* @return sum
*/
Expression sum(Expression x, N y);
/**
* Create an expression that returns the product
* of its arguments.
*
* @param x expression
* @param y value
*
* @return product
*/
Expression prod(Expression x, N y);
/**
* Create an expression that returns the difference
* between its arguments.
*
* @param x expression
* @param y value
*
* @return difference
*/
Expression diff(Expression x, N y);
/**
* Create an expression that returns the sum
* of its arguments.
*
* @param x value
* @param y expression
*
* @return sum
*/
Expression sum(N x, Expression y);
/**
* Create an expression that returns the product
* of its arguments.
*
* @param x value
* @param y expression
*
* @return product
*/
Expression prod(N x, Expression y);
/**
* Create an expression that returns the difference
* between its arguments.
*
* @param x value
* @param y expression
*
* @return difference
*/
Expression diff(N x, Expression y);
/**
* Create an expression that returns the quotient
* of its arguments.
*
* @param x expression
* @param y expression
*
* @return quotient
*/
Expression quot(Expression x, Expression y);
/**
* Create an expression that returns the quotient
* of its arguments.
*
* @param x expression
* @param y value
*
* @return quotient
*/
Expression quot(Expression x, Number y);
/**
* Create an expression that returns the quotient
* of its arguments.
*
* @param x value
* @param y expression
*
* @return quotient
*/
Expression quot(Number x, Expression y);
/**
* Create an expression that returns the modulus
* of its arguments.
*
* @param x expression
* @param y expression
*
* @return modulus
*/
Expression mod(Expression x, Expression y);
/**
* Create an expression that returns the modulus
* of its arguments.
*
* @param x expression
* @param y value
*
* @return modulus
*/
Expression mod(Expression x, Integer y);
/**
* Create an expression that returns the modulus
* of its arguments.
*
* @param x value
* @param y expression
*
* @return modulus
*/
Expression mod(Integer x, Expression y);
/**
* Create an expression that returns the square root
* of its argument.
*
* @param x expression
*
* @return square root
*/
Expression sqrt(Expression x);
//typecasts:
/**
* Typecast.
*
* @param number numeric expression
*
* @return Expression
*/
Expression toLong(Expression number);
/**
* Typecast.
*
* @param number numeric expression
*
* @return Expression
*/
Expression toInteger(Expression number);
/**
* Typecast.
*
* @param number numeric expression
*
* @return Expression
*/
Expression toFloat(Expression number);
/**
* Typecast.
*
* @param number numeric expression
*
* @return Expression
*/
Expression toDouble(Expression number);
/**
* Typecast.
*
* @param number numeric expression
*
* @return Expression
*/
Expression toBigDecimal(Expression number);
/**
* Typecast.
*
* @param number numeric expression
*
* @return Expression
*/
Expression toBigInteger(Expression number);
/**
* Typecast.
*
* @param character expression
*
* @return Expression
*/
Expression toString(Expression character);
//literals:
/**
* Create an expression literal.
*
* @param value
*
* @return expression literal
*/
Expression literal(T value);
//parameters:
/**
* Create a parameter expression.
*
* @param paramClass parameter class
*
* @return parameter expression
*/
ParameterExpression parameter(Class paramClass);
/**
* Create a parameter expression with the given name.
*
* @param paramClass parameter class
* @param name
*
* @return parameter expression
*/
ParameterExpression parameter(Class paramClass, String name);
//collection operations:
/**
* Create a predicate that tests whether a collection is empty.
*
* @param collection expression
*
* @return predicate
*/
> Predicate isEmpty(Expression collection);
/**
* Create a predicate that tests whether a collection is
* not empty.
*
* @param collection expression
*
* @return predicate
*/
> Predicate isNotEmpty(Expression collection);
/**
* Create an expression that tests the size of a collection.
*
* @param collection
*
* @return size expression
*/
> Expression size(C collection);
/**
* Create an expression that tests the size of a collection.
*
* @param collection expression
*
* @return size expression
*/
> Expression size(Expression collection);
/**
* Create a predicate that tests whether an element is
* a member of a collection.
*
* @param elem element
* @param collection expression
*
* @return predicate
*/
> Predicate isMember(E elem, Expression collection);
/**
* Create a predicate that tests whether an element is
* not a member of a collection.
*
* @param elem element
* @param collection expression
*
* @return predicate
*/
> Predicate isNotMember(E elem, Expression collection);
/**
* Create a predicate that tests whether an element is
* a member of a collection.
*
* @param elem element expression
* @param collection expression
*
* @return predicate
*/
> Predicate isMember(Expression elem, Expression collection);
/**
* Create a predicate that tests whether an element is
* not a member of a collection.
*
* @param elem element expression
* @param collection expression
*
* @return predicate
*/
> Predicate isNotMember(Expression elem, Expression collection);
//get the values and keys collections of the Map, which may then
//be passed to size(), isMember(), isEmpty(), etc
/**
* Create an expression that returns the values of a map.
*
* @param map
*
* @return collection expression
*/
> Expression> values(M map);
/**
* Create an expression that returns the keys of a map.
*
* @param map
*
* @return set expression
*/
> Expression> keys(M map);
//string functions:
/**
* Create a predicate for testing whether the expression
* satisfies the given pattern.
*
* @param x string expression
* @param pattern string expression
*
* @return like predicate
*/
Predicate like(Expression x, Expression pattern);
/**
* Create a predicate for testing whether the expression
* satisfies the given pattern.
*
* @param x string expression
* @param pattern string expression
* @param escapeChar escape character expression
*
* @return like predicate
*/
Predicate like(Expression x, Expression pattern, Expression escapeChar);
/**
* Create a predicate for testing whether the expression
* satisfies the given pattern.
*
* @param x string expression
* @param pattern string expression
* @param escapeChar escape character
*
* @return like predicate
*/
Predicate like(Expression x, Expression pattern, char escapeChar);
/**
* Create a predicate for testing whether the expression
* satisfies the given pattern.
*
* @param x string expression
* @param pattern string
*
* @return like predicate
*/
Predicate like(Expression x, String pattern);
/**
* Create a predicate for testing whether the expression
* satisfies the given pattern.
*
* @param x string expression
* @param pattern string
* @param escapeChar escape character expression
*
* @return like predicate
*/
Predicate like(Expression x, String pattern, Expression escapeChar);
/**
* Create a predicate for testing whether the expression
* satisfies the given pattern.
*
* @param x string expression
* @param pattern string
* @param escapeChar escape character
*
* @return like predicate
*/
Predicate like(Expression x, String pattern, char escapeChar);
/**
* Create a predicate for testing whether the expression
* does not satisfy the given pattern.
*
* @param x string expression
* @param pattern string expression
*
* @return like predicate
*/
Predicate notLike(Expression x, Expression pattern);
/**
* Create a predicate for testing whether the expression
* does not satisfy the given pattern.
*
* @param x string expression
* @param pattern string expression
* @param escapeChar escape character expression
*
* @return like predicate
*/
Predicate notLike(Expression x, Expression pattern, Expression escapeChar);
/**
* Create a predicate for testing whether the expression
* does not satisfy the given pattern.
*
* @param x string expression
* @param pattern string expression
* @param escapeChar escape character
*
* @return like predicate
*/
Predicate notLike(Expression x, Expression pattern, char escapeChar);
/**
* Create a predicate for testing whether the expression
* does not satisfy the given pattern.
*
* @param x string expression
* @param pattern string
*
* @return like predicate
*/
Predicate notLike(Expression x, String pattern);
/**
* Create a predicate for testing whether the expression
* does not satisfy the given pattern.
*
* @param x string expression
* @param pattern string
* @param escapeChar escape character expression
*
* @return like predicate
*/
Predicate notLike(Expression x, String pattern, Expression escapeChar);
/**
* Create a predicate for testing whether the expression
* does not satisfy the given pattern.
*
* @param x string expression
* @param pattern string
* @param escapeChar escape character
*
* @return like predicate
*/
Predicate notLike(Expression x, String pattern, char escapeChar);
/**
* String concatenation operation.
*
* @param x string expression
* @param y string expression
*
* @return expression corresponding to concatenation
*/
Expression concat(Expression x, Expression y);
/**
* String concatenation operation.
*
* @param x string expression
* @param y string
*
* @return expression corresponding to concatenation
*/
Expression concat(Expression x, String y);
/**
* String concatenation operation.
*
* @param x string
* @param y string expression
*
* @return expression corresponding to concatenation
*/
Expression concat(String x, Expression y);
/**
* Substring extraction operation.
* Extracts a substring starting at specified position through
* to end of the string.
* First position is 1.
*
* @param x string expression
* @param from start position expression
*
* @return expression corresponding to substring extraction
*/
Expression substring(Expression x, Expression from);
/**
* Substring extraction operation.
* Extracts a substring starting at specified position through
* to end of the string.
* First position is 1.
*
* @param x string expression
* @param from start position
*
* @return expression corresponding to substring extraction
*/
Expression substring(Expression x, int from);
/**
* Substring extraction operation.
* Extracts a substring of given length starting at
* specified position.
* First position is 1.
*
* @param x string expression
* @param from start position expression
* @param len length expression
*
* @return expression corresponding to substring extraction
*/
Expression substring(Expression x, Expression from, Expression len);
/**
* Substring extraction operation.
* Extracts a substring of given length starting at
* specified position.
* First position is 1.
*
* @param x string expression
* @param from start position
* @param len length
*
* @return expression corresponding to substring extraction
*/
Expression substring(Expression x, int from, int len);
public static enum Trimspec {
LEADING, TRAILING, BOTH
}
/**
* Create expression to trim blanks from both ends of
* a string.
*
* @param x expression for string to trim
*
* @return trim expression
*/
Expression trim(Expression x);
/**
* Create expression to trim blanks from a string.
*
* @param ts trim specification
* @param x expression for string to trim
*
* @return trim expression
*/
Expression trim(Trimspec ts, Expression x);
/**
* Create expression to trim character from both ends of
* a string.
*
* @param t expression for character to be trimmed
* @param x expression for string to trim
*
* @return trim expression
*/
Expression trim(Expression t, Expression x);
/**
* Create expression to trim character from a string.
*
* @param ts trim specification
* @param t expression for character to be trimmed
* @param x expression for string to trim
*
* @return trim expression
*/
Expression trim(Trimspec ts, Expression t, Expression x);
/**
* Create expression to trim character from both ends of
* a string.
*
* @param t character to be trimmed
* @param x expression for string to trim
*
* @return trim expression
*/
Expression trim(char t, Expression x);
/**
* Create expression to trim character from a string.
*
* @param ts trim specification
* @param t character to be trimmed
* @param x expression for string to trim
*
* @return trim expression
*/
Expression trim(Trimspec ts, char t, Expression x);
/**
* Create expression for converting a string to lowercase.
*
* @param x string expression
*
* @return expression to convert to lowercase
*/
Expression lower(Expression x);
/**
* Create expression for converting a string to uppercase.
*
* @param x string expression
*
* @return expression to convert to uppercase
*/
Expression upper(Expression x);
/**
* Create expression to return length of a string.
*
* @param x string expression
*
* @return length expression
*/
Expression length(Expression x);
/**
* 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.
*
* @param x expression for string to be searched
* @param pattern expression for string to be located
*
* @return expression corresponding to position
*/
Expression locate(Expression x, Expression 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.
*
* @param x expression for string to be searched
* @param pattern expression for string to be located
* @param from expression for position at which to start search
*
* @return expression corresponding to position
*/
Expression locate(Expression x, Expression pattern, Expression 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.
*
* @param x expression for string to be searched
* @param pattern string to be located
*
* @return expression corresponding to position
*/
Expression locate(Expression x, String pattern);
/**
* Create expression to locate the position of one string
* within another, returning position of first character
* if found.
* The first position in a string is denoted by 1. If the
* string to be located is not found, 0 is returned.
*
* @param x expression for string to be searched
* @param pattern string to be located
* @param from position at which to start search
*
* @return expression corresponding to position
*/
Expression locate(Expression x, String pattern, int from);
// Date/time/timestamp functions:
/**
* Create expression to return current date.
*
* @return expression for current date
*/
Expression currentDate();
/**
* Create expression to return current timestamp.
*
* @return expression for current timestamp
*/
Expression currentTimestamp();
/**
* Create expression to return current time.
*
* @return expression for current time
*/
Expression currentTime();
//in builders:
/**
* Interface used to build in-expressions.
*/
public static interface In extends Predicate {
/**
* Returns the expression to be tested against the
* list of values.
*
* @return expression
*/
Expression getExpression();
/**
* Add to list of values to be tested against.
*
* @param value
*
* @return in predicate
*/
In value(T value);
/**
* Add to list of values to be tested against.
*
* @param value expression
*
* @return in predicate
*/
In value(Expression value);
}
/**
* Create predicate to test whether given expression
* is contained in a list of values.
*
* @param expression to be tested against list of values
*
* @return in predicate
*/
In in(Expression expression);
//coalesce, nullif:
/**
* Create an expression that returns null if all its arguments
* evaluate to null, and the value of the first non-null argument
* otherwise.
*
* @param x expression
* @param y expression
*
* @return expression corresponding to the given coalesce
* expression
*/
Expression coalesce(Expression x, Expression y);
/**
* Create an expression that returns null if all its arguments
* evaluate to null, and the value of the first non-null argument
* otherwise.
*
* @param x expression
* @param y value
*
* @return coalesce expression
*/
Expression coalesce(Expression 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.
*
* @param x expression
* @param y expression
*
* @return expression corresponding to the given nullif
* expression
*/
Expression nullif(Expression 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.
*
* @param x expression
* @param y value
*
* @return expression corresponding to the given nullif
* expression
*/
Expression nullif(Expression x, Y y);
// coalesce builder:
/**
* Interface used to build coalesce expressions.
* A coalesce expression is equivalent to a case expression
* that returns null if all its arguments evaluate to null,
* and the value of its first non-null argument otherwise.
*/
public static interface Coalesce extends Expression {
/**
* Add an argument to the coalesce expression.
*
* @param value
*
* @return coalesce expression
*/
Coalesce value(T value);
/**
* Add an argument to the coalesce expression.
*
* @param value expression
*
* @return coalesce expression
*/
Coalesce value(Expression value);
}
/**
* Create a coalesce expression.
*
* @return coalesce expression
*/
Coalesce coalesce();
//case builders:
/**
* Interface used to build simple case expressions.
*/
public static interface SimpleCase extends Expression {
/**
* Returns the expression to be tested against the
* conditions.
*
* @return expression
*/
Expression getExpression();
/**
* Add a when/then clause to the case expression.
*
* @param condition "when" condition
* @param result "then" result value
*
* @return simple case expression
*/
SimpleCase when(C condition, R result);
/**
* Add a when/then clause to the case expression.
*
* @param condition "when" condition
* @param result "then" result expression
*
* @return simple case expression
*/
SimpleCase when(C condition, Expression result);
/**
* Add an "else" clause to the case expression.
*
* @param result "else" result
*
* @return expression
*/
Expression otherwise(R result);
/**
* Add an "else" clause to the case expression.
*
* @param result "else" result expression
*
* @return expression
*/
Expression otherwise(Expression result);
}
/**
* Create simple case expression.
*
* @param expression to be tested against the case conditions
*
* @return simple case expression
*/
SimpleCase selectCase(Expression expression);
/**
* Interface used to build general case expressions.
*/
public static interface Case extends Expression {
/**
* Add a when/then clause to the case expression.
*
* @param condition "when" condition
* @param result "then" result value
*
* @return general case expression
*/
Case when(Expression condition, R result);
/**
* Add a when/then clause to the case expression.
*
* @param condition "when" condition
* @param result "then" result expression
*
* @return general case expression
*/
Case when(Expression 