Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Hibernate, Relational Persistence for Idiomatic Java
   *
   * Copyright (c) 2009 by Red Hat Inc and/or its affiliates or by
   * third-party contributors as indicated by either @author tags or express
   * copyright attribution statements applied by the authors.  All
   * third-party contributions are distributed under license by Red Hat Inc.
   *
   * This copyrighted material is made available to anyone wishing to use, modify,
  * copy, or redistribute it subject to the terms and conditions of the GNU
  * Lesser General Public License, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
  * for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this distribution; if not, write to:
  * Free Software Foundation, Inc.
  * 51 Franklin Street, Fifth Floor
  * Boston, MA  02110-1301  USA
  */
 package org.hibernate.ejb.criteria;
 
 import java.util.List;
 import java.util.Set;
 
The Hibernate implementation of the JPA javax.persistence.criteria.CriteriaQuery contract. Mostly a set of delegation to its internal QueryStructure.

Author(s):
Steve Ebersole
 
 public class CriteriaQueryImpl<T> extends AbstractNode implements CriteriaQuery<T>, Serializable {
 	private final Class<T> returnType;
 
 	private final QueryStructure<T> queryStructure;
 	private List<OrderorderSpecs = Collections.emptyList();
 
 
 			CriteriaBuilderImpl criteriaBuilder,
 			Class<T> returnType) {
 		supercriteriaBuilder );
 		this. = returnType;
 		this. = new QueryStructure<T>( thiscriteriaBuilder );
 	}

 
 	public Class<T> getResultType() {
 		return ;
 	}
 
 
 	// SELECTION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
 	public CriteriaQuery<T> distinct(boolean applyDistinction) {
 		.setDistinctapplyDistinction );
 		return this;
 	}

 
 	public boolean isDistinct() {
 	}

 
 	@SuppressWarnings({ "unchecked" })
 	public Selection<T> getSelection() {
 		return ( Selection<T> ) .getSelection();
 	}
 
 	public void applySelection(Selection<? extends T> selection) {
	}

	public CriteriaQuery<T> select(Selection<? extends T> selection) {
		applySelectionselection );
		return this;
	}

	@SuppressWarnings({ "unchecked" })
	public CriteriaQuery<T> multiselect(Selection<?>... selections) {
		return multiselect( Arrays.asListselections ) );
	}

	@SuppressWarnings({ "unchecked" })
	public CriteriaQuery<T> multiselect(List<Selection<?>> selections) {
		final Selection<? extends T> selection;
		if ( Tuple.class.isAssignableFromgetResultType() ) ) {
			selection = ( Selection<? extends T> ) criteriaBuilder().tupleselections );
		}
		else if ( getResultType().isArray() ) {
			selection = ( Selection<? extends T> )  criteriaBuilder().array(
Class<? extends Object[]> ) getResultType(),
					selections
			);
		}
		else if ( Object.class.equalsgetResultType() ) ) {
			switch ( selections.size() ) {
				case 0: {
							"empty selections passed to criteria query typed as Object"
					);
				}
				case 1: {
					selection = ( Selection<? extends T> ) selections.get( 0 );
					break;
				}
				default: {
					selection = ( Selection<? extends T> ) criteriaBuilder().arrayselections );
				}
			}
		}
		else {
			selection = criteriaBuilder().constructgetResultType(), selections );
		}
		applySelectionselection );
		return this;
	}
	// ROOTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public Set<Root<?>> getRoots() {
	}

	public <X> Root<X> from(EntityType<X> entityType) {
		return .fromentityType );
	}

	public <X> Root<X> from(Class<X> entityClass) {
		return .fromentityClass );
	}
	// RESTRICTION ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	}

	public CriteriaQuery<T> where(Expression<Booleanexpression) {
		return this;
	}

	public CriteriaQuery<T> where(Predicate... predicates) {
		// TODO : assuming this should be a conjuntion, but the spec does not say specifically...
		return this;
	}
	// GROUPING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public List<Expression<?>> getGroupList() {
	}

	public CriteriaQuery<T> groupBy(Expression<?>... groupings) {
		return this;
	}
	public CriteriaQuery<T> groupBy(List<Expression<?>> groupings) {
		return this;
	}

	}

	public CriteriaQuery<T> having(Expression<Booleanexpression) {
		return this;
	}

	public CriteriaQuery<T> having(Predicate... predicates) {
		return this;
	}
	// ORDERING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	public List<OrdergetOrderList() {
		return ;
	}

	public CriteriaQuery<T> orderBy(Order... orders) {
		if ( orders != null && orders.length > 0 ) {
			 = Arrays.asListorders );
		}
		else {
			 = Collections.emptyList();
		}
		return this;
	}

	public CriteriaQuery<T> orderBy(List<Orderorders) {
		 = orders;
		return this;
	}

	}

	public <U> Subquery<U> subquery(Class<U> subqueryType) {
		return .subquerysubqueryType );
	}
	public void validate() {
		// getRoots() is explicitly supposed to return empty if none defined, no need to check for null
		if ( getRoots().isEmpty() ) {
			throw new IllegalStateException"No criteria query roots were specified" );
		}
		// if there is not an explicit selection, there is an *implicit* selection of the root entity provided only
		// a single query root was defined.
		if ( getSelection() == null && !hasImplicitSelection() ) {
			throw new IllegalStateException"No explicit selection and an implicit one cold not be determined" );
		}
	}

If no explicit selection was defined, we have a condition called an implicit selection if the query specified a single javax.persistence.criteria.Root and the java type of that root's model is the same as this criteria's result type.

Returns:
True if there is an explicit selection; false otherwise.
	private boolean hasImplicitSelection() {
		if ( getRoots().size() != 1 ) {
			return false;
		}
		Root root = getRoots().iterator().next();
		if ( root.getModel().getJavaType() !=  ) {
			return false;
		}
		// if we get here, the query defined no selection but defined a single root of the same type as the
		// criteria query return, so we use that as the implicit selection
		//
		// todo : should we put an implicit marker in the selection to this fact to make later processing easier?
		return true;
	}
		final StringBuilder jpaqlQuery = new StringBuilder();
		.renderjpaqlQueryrenderingContext );
		if ( ! getOrderList().isEmpty() ) {
			jpaqlQuery.append" order by " );
			String sep = "";
			for ( Order orderSpec : getOrderList() ) {
				jpaqlQuery.appendsep )
						.append( ( ( Renderable ) orderSpec.getExpression() ).renderrenderingContext ) )
						.appendorderSpec.isAscending() ? " asc" : " desc" );
				sep = ", ";
			}
		}
			public String getQueryString() {
				return jpaqlQuery.toString();
			}
			@SuppressWarnings({ "unchecked" })
				return selection == null
null
selection.getValueHandlers();
			}
					public void validate(Type[] returnTypes) {
						if ( selection != null ) {
							if ( selection.isCompoundSelection() ) {
								if ( returnTypes.length != selection.getCompoundSelectionItems().size() ) {
											"Number of return values [" + returnTypes.length +
													"] did not match expected [" +
													selection.getCompoundSelectionItems().size() + "]"
									);
								}
							}
							else {
								if ( returnTypes.length > 1 ) {
											"Number of return values [" + returnTypes.length +
													"] did not match expected [1]"
									);
								}
							}
						}
					}
				};
			}
		};
	}
New to GrepCode? Check out our FAQ X