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.
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;
/**
* Used to construct criteria queries, compound selections, expressions, predicates, 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 CriteriaBuilder {
/**
* Interface used to build general case expressions. Case conditions are evaluated in the order in which they are specified.
*
* @param
* the type of the case
*/
public static interface Case extends Expression {
/**
* Add an "else" clause to the case expression.
*
* @param result
* "else" result expression
* @return expression
*/
Expression otherwise(Expression result);
/**
* Add an "else" clause to the case expression.
*
* @param result
* "else" result
* @return expression
*/
Expression otherwise(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 condition, Expression result);
/**
* 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);
}
/**
* 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.
*
* @param
* the type of the coalesce
*/
public static interface Coalesce extends Expression {
/**
* Add an argument to the coalesce expression.
*
* @param value
* expression
* @return coalesce expression
*/
Coalesce value(Expression value);
/**
* Add an argument to the coalesce expression.
*
* @param value
* value
* @return coalesce expression
*/
Coalesce value(T value);
}
/**
* Interface used to build in predicates.
*
* @param
* the type of the in
*/
public static interface In extends Predicate {
/**
* Return 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
* expression
* @return in predicate
*/
In value(Expression value);
/**
* Add to list of values to be tested against.
*
* @param value
* value
* @return in predicate
*/
In value(T value);
}
/**
* Interface used to build simple case expressions. Case conditions are evaluated in the order in which they are specified.
*
* @param
* the type of the case
* @param
* the type of the result
*/
public static interface SimpleCase extends Expression {
/**
* Return the expression to be tested against the conditions.
*
* @return expression
*/
Expression getExpression();
/**
* Add an "else" clause to the case expression.
*
* @param result
* "else" result expression
* @return expression
*/
Expression otherwise(Expression result);
/**
* Add an "else" clause to the case expression.
*
* @param result
* "else" result
* @return expression
*/
Expression otherwise(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 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);
}
/**
* Types for Trimspec.
*
*/
public static enum Trimspec {
/**
* Trim from leading end.
*/
LEADING,
/**
* Trim from trailing end.
*/
TRAILING,
/**
* Trim from both ends.
*/
BOTH
}
/**
* Create an expression that returns the absolute value of its argument.
*
* @param x
* expression
* @param
* the type of the expression
* @return absolute value
*/
Expression abs(Expression x);
/**
* Create an all expression over the subquery results.
*
* @param subquery
* @param
* the type of the expression
* @return all expression
*/
Expression all(Subquery subquery);
/**
* 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 conjunction of the given restriction predicates. A conjunction of zero predicates is true.
*
* @param restrictions
* zero or more restriction predicates
* @return and predicate
*/
Predicate and(Predicate... restrictions);
/**
* Create an any expression over the subquery results. This expression is equivalent to a some expression.
*
* @param subquery
* @param
* the type of the expression
* @return any expression
*/
Expression any(Subquery subquery);
/**
* Create an 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);
/**
* 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 aggregate expression applying the avg operation.
*
* @param x
* expression representing input value to avg operation
* @param
* the type of the expression
* @return avg expression
*/
Expression avg(Expression x);
/**
* 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
* @param
* the type of the expression
* @return between predicate
*/
> Predicate between(Expression v, 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
* value
* @param y
* value
* @param
* the type of the expression
* @return between predicate
*/
> Predicate between(Expression v, Y x, Y y);
/**
* Create a coalesce expression.
*
* @param
* the type of the coalesce
* @return coalesce expression
*/
Coalesce coalesce();
/**
* 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
* @param
* the type of the expression
* @return 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
* @param
* the type of the expression
* @return coalesce expression
*/
Expression coalesce(Expression x, Y y);
/**
* Create an expression for string concatenation.
*
* @param x
* string expression
* @param y
* string expression
* @return expression corresponding to concatenation
*/
Expression concat(Expression x, Expression y);
/**
* Create an expression for string concatenation.
*
* @param x
* string expression
* @param y
* string
* @return expression corresponding to concatenation
*/
Expression concat(Expression x, String y);
/**
* Create an expression for string concatenation.
*
* @param x
* string
* @param y
* string expression
* @return expression corresponding to concatenation
*/
Expression concat(String x, Expression y);
/**
* Create a conjunction (with zero conjuncts). A conjunction with zero conjuncts is true.
*
* @return and predicate
*/
Predicate conjunction();
/**
* 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.
*
* @param resultClass
* class whose instance is to be constructed
* @param selections
* arguments to the constructor
* @param
* the type of the selection
* @return compound selection item
* @throws IllegalArgumentException
* if an argument is a tuple- or array-valued selection item
*/
CompoundSelection construct(Class resultClass, Selection... selections);
/**
* Create an aggregate expression applying the count operation.
*
* @param x
* expression representing input value to count operation
* @return count expression
*/
Expression count(Expression x);
/**
* Create an aggregate expression applying the count distinct operation.
*
* @param x
* expression representing input value to count distinct operation
* @return count distinct expression
*/
Expression countDistinct(Expression x);
/**
* Create a CriteriaQuery object.
*
* @return criteria query object
*/
CriteriaQuery
