/******************************************************************************* | |
* Copyright (c) 2008 - 2012 Oracle Corporation. All rights reserved. | |
* | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* Linda DeMichiel - Java Persistence 2.1 | |
* Linda DeMichiel - Java Persistence 2.0 | |
* | |
******************************************************************************/ | |
package javax.persistence.criteria; | |
import java.util.List; | |
import java.util.Set; | |
/** | |
* The <code>AbstractQuery</code> interface defines functionality that is common | |
* to both top-level queries and subqueries. | |
* It is not intended to be used directly in query construction. | |
* | |
* <p> All queries must have: | |
* a set of root entities (which may in turn own joins). | |
* <p> All queries may have: | |
* a conjunction of restrictions. | |
* | |
* @param <T> the type of the result | |
* | |
* @since Java Persistence 2.0 | |
*/ | |
public interface AbstractQuery<T> extends CommonAbstractQuery { | |
/** | |
* Modify the query to restrict the query results according | |
* to the specified boolean expression. | |
* Replaces the previously added restriction(s), if any. | |
* @param restriction a simple or compound boolean expression | |
* @return the modified query | |
*/ | |
AbstractQuery<T> where(Expression<Boolean> restriction); | |
/** | |
* Modify the query to restrict the query results according | |
* to the conjunction of the specified restriction predicates. | |
* Replaces the previously added restriction(s), if any. | |
* If no restrictions are specified, any previously added | |
* restrictions are simply removed. | |
* @param restrictions zero or more restriction predicates | |
* @return the modified query | |
*/ | |
AbstractQuery<T> where(Predicate... restrictions); | |
/** | |
* Specify the expressions that are used to form groups over | |
* the query results. | |
* Replaces the previous specified grouping expressions, if any. | |
* If no grouping expressions are specified, any previously | |
* added grouping expressions are simply removed. | |
* @param grouping zero or more grouping expressions | |
* @return the modified query | |
*/ | |
AbstractQuery<T> groupBy(Expression<?>... grouping); | |
/** | |
* Specify the expressions that are used to form groups over | |
* the query results. | |
* Replaces the previous specified grouping expressions, if any. | |
* If no grouping expressions are specified, any previously | |
* added grouping expressions are simply removed. | |
* @param grouping list of zero or more grouping expressions | |
* @return the modified query | |
*/ | |
AbstractQuery<T> groupBy(List<Expression<?>> grouping); | |
/** | |
* Specify a restriction over the groups of the query. | |
* Replaces the previous having restriction(s), if any. | |
* @param restriction a simple or compound boolean expression | |
* @return the modified query | |
*/ | |
AbstractQuery<T> having(Expression<Boolean> restriction); | |
/** | |
* Specify restrictions over the groups of the query | |
* according the conjunction of the specified restriction | |
* predicates. | |
* Replaces the previously having added restriction(s), if any. | |
* If no restrictions are specified, any previously added | |
* restrictions are simply removed. | |
* @param restrictions zero or more restriction predicates | |
* @return the modified query | |
*/ | |
AbstractQuery<T> having(Predicate... restrictions); | |
/** | |
* Specify whether duplicate query results will be eliminated. | |
* A true value will cause duplicates to be eliminated. | |
* A false value will cause duplicates to be retained. | |
* If distinct has not been specified, duplicate results must | |
* be retained. | |
* @param distinct boolean value specifying whether duplicate | |
* results must be eliminated from the query result or | |
* whether they must be retained | |
* @return the modified query | |
*/ | |
AbstractQuery<T> distinct(boolean distinct); | |
/** | |
* Return the query roots. These are the roots that have | |
* been defined for the <code>CriteriaQuery</code> or <code>Subquery</code> itself, | |
* including any subquery roots defined as a result of | |
* correlation. Returns empty set if no roots have been defined. | |
* Modifications to the set do not affect the query. | |
* @return the set of query roots | |
*/ | |
Set<Root<?>> getRoots(); | |
/** | |
* Return the selection of the query, or null if no selection | |
* has been set. | |
* @return selection item | |
*/ | |
Selection<T> getSelection(); | |
/** | |
* Return a list of the grouping expressions. Returns empty | |
* list if no grouping expressions have been specified. | |
* Modifications to the list do not affect the query. | |
* @return the list of grouping expressions | |
*/ | |
List<Expression<?>> getGroupList(); | |
/** | |
* Return the predicate that corresponds to the restriction(s) | |
* over the grouping items, or null if no restrictions have | |
* been specified. | |
* @return having clause predicate | |
*/ | |
Predicate getGroupRestriction(); | |
/** | |
* Return whether duplicate query results must be eliminated or | |
* retained. | |
* @return boolean indicating whether duplicate query results | |
* must be eliminated | |
*/ | |
boolean isDistinct(); | |
/** | |
* Return the result type of the query or subquery. If a result | |
* type was specified as an argument to the | |
* <code>createQuery</code> or <code>subquery</code> method, that | |
* type will be returned. If the query was created using the | |
* <code>createTupleQuery</code> method, the result type is | |
* <code>Tuple</code>. Otherwise, the result type is | |
* <code>Object</code>. | |
* @return result type | |
*/ | |
Class<T> getResultType(); | |
} |