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.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
Compiles a JPA criteria query into an executable javax.persistence.TypedQuery. Its single contract is the compile(javax.persistence.criteria.CriteriaQuery) method.

NOTE : This is a temporary implementation which simply translates the criteria query into a JPAQL query string. A better, long-term solution is being implemented as part of refactoring the JPAQL/HQL translator.

Author(s):
Steve Ebersole
 
 public class CriteriaQueryCompiler implements Serializable {
 
     private static final EntityManagerMessageLogger LOG = Logger.getMessageLogger(EntityManagerMessageLogger.class,
                                                                            CriteriaQueryCompiler.class.getName());

Used to describe implicit (not defined in criteria query) parameters.
 
 	public static interface ImplicitParameterBinding {
Retrieve the generated name of the implicit parameter.

Returns:
The parameter name.
 
 		public String getParameterName();

Get the java type of the "thing" that led to the implicit parameter. Used from org.hibernate.ejb.HibernateEntityManagerImplementor.Options.getNamedParameterExplicitTypes() in determining "guessed type" overriding.

Returns:
The java type
 
 		public Class getJavaType();

Bind the implicit parameter's value to the JPA query.

Parameters:
typedQuery The JPA query.
 
 		public void bind(TypedQuery typedQuery);
 	}

Used to provide a context and services to the rendering.
 
 	public static interface RenderingContext {
Generate a correlation name.

Returns:
The generated correlation name
		public String generateAlias();

Register parameters explicitly encountered in the criteria query.

Parameters:
criteriaQueryParameter The parameter expression
Returns:
The JPA-QL parameter name
		public String registerExplicitParameter(ParameterExpression<?> criteriaQueryParameter);

Register a parameter that was not part of the criteria query (at least not as a parameter).

Parameters:
literal The literal value
javaType The java type as whcih to handle the literal value.
Returns:
The JPA-QL parameter name
		public String registerLiteralParameterBinding(Object literalClass javaType);

Given a java type, determine the proper cast type name.

Parameters:
javaType The java type.
Returns:
The cast type name.
		public String getCastType(Class javaType);
	}
	public static interface RenderedCriteriaQuery {
	}
		this. = entityManager;
	}
	public <T> TypedQuery<T> compile(CriteriaQuery<T> criteriaQuery) {
		CriteriaQueryImpl<T> criteriaQueryImpl = ( CriteriaQueryImpl<T> ) criteriaQuery;
		criteriaQueryImpl.validate();
		final Map<ParameterExpression<?>,StringexplicitParameterMapping = new HashMap<ParameterExpression<?>,String>();
		final Map<String,ParameterExpression<?>> explicitParameterNameMapping = new HashMap<String,ParameterExpression<?>>();
		final List<ImplicitParameterBindingimplicitParameterBindings = new ArrayList<ImplicitParameterBinding>();
		final Map<String,ClassimplicitParameterTypes = new HashMap<StringClass>();
		RenderingContext renderingContext = new RenderingContext() {
			private int aliasCount = 0;
			private int explicitParameterCount = 0;
			public String generateAlias() {
				return "generatedAlias" + ++;
			}
				return "param" + ++;
			}
			public String registerExplicitParameter(ParameterExpression<?> criteriaQueryParameter) {
				final String jpaqlParameterName;
				if ( explicitParameterMapping.containsKeycriteriaQueryParameter ) ) {
					jpaqlParameterName = explicitParameterMapping.getcriteriaQueryParameter );
				}
				else {
					jpaqlParameterName = generateParameterName();
					explicitParameterMapping.putcriteriaQueryParameterjpaqlParameterName );
				}
				if ( StringHelper.isNotEmptycriteriaQueryParameter.getName() ) ) {
					explicitParameterNameMapping.put(
							criteriaQueryParameter.getName(),
							criteriaQueryParameter
					);
				}
				return jpaqlParameterName;
			}
			public String registerLiteralParameterBinding(final Object literalfinal Class javaType) {
				final String parameterName = generateParameterName();
						return parameterName;
					}
					public Class getJavaType() {
						return javaType;
					}
					public void bind(TypedQuery typedQuery) {
						typedQuery.setParameterparameterNameliteral );
					}
				};
				implicitParameterBindings.addbinding );
				implicitParameterTypes.putparameterNamejavaType );
				return parameterName;
			}
			public String getCastType(Class javaType) {
				Type hibernateType = factory.getTypeResolver().heuristicTypejavaType.getName() );
				if ( hibernateType == null ) {
							"Could not convert java type [" + javaType.getName() + "] to Hibernate type"
					);
				}
				return hibernateType.getName();
			}
		};
		final RenderedCriteriaQuery renderedCriteriaQuery = criteriaQueryImpl.renderrenderingContext );
        .debugf("Rendered criteria query -> %s"renderedCriteriaQuery.getQueryString());
				renderedCriteriaQuery.getQueryString(),
				criteriaQuery.getResultType(),
				criteriaQuery.getSelection(),
						return renderedCriteriaQuery.getValueHandlers();
					}
						return implicitParameterTypes;
					}
						return renderedCriteriaQuery.getResultMetadataValidator();
					}
				}
		);
		for ( ImplicitParameterBinding implicitParameterBinding : implicitParameterBindings ) {
			implicitParameterBinding.bindjpaqlQuery );
		}
		return wrapjpaqlQueryexplicitParameterMappingexplicitParameterNameMapping );
	}
	private <X> TypedQuery<X> wrap(
			final TypedQuery<X> jpaqlQuery,
			final Map<ParameterExpression<?>, StringexplicitParameterMapping,
			final Map<StringParameterExpression<?>> explicitParameterNameMapping) {
		return new TypedQuery<X>() {
			public List<X> getResultList() {
				return jpaqlQuery.getResultList();
			}
			public X getSingleResult() {
				return jpaqlQuery.getSingleResult();
			}
			public int getMaxResults() {
				return jpaqlQuery.getMaxResults();
			}
			public TypedQuery<X> setMaxResults(int i) {
				jpaqlQuery.setMaxResultsi );
				return this;
			}
			public int getFirstResult() {
				return jpaqlQuery.getFirstResult();
			}
			public TypedQuery<X> setFirstResult(int i) {
				jpaqlQuery.setFirstResulti );
				return this;
			}
			public Map<StringObjectgetHints() {
				return jpaqlQuery.getHints();
			}
			public TypedQuery<X> setHint(String nameObject value) {
				jpaqlQuery.setHintnamevalue);
				return this;
			}
				return jpaqlQuery.getFlushMode();
			}
			public TypedQuery<X> setFlushMode(FlushModeType flushModeType) {
				jpaqlQuery.setFlushModeflushModeType );
				return this;
			}
				return jpaqlQuery.getLockMode();
			}
			public TypedQuery<X> setLockMode(LockModeType lockModeType) {
				jpaqlQuery.setLockModelockModeType );
				return this;
			}
			@SuppressWarnings({ "unchecked" })
			public Set getParameters() {
				return explicitParameterMapping.keySet();
			}
			public boolean isBound(Parameter<?> param) {
				return jpaqlQuery.isBoundparam );
			}
			@SuppressWarnings({ "unchecked" })
			public <T> T getParameterValue(Parameter<T> param) {
				return ( T ) jpaqlQuery.getParameterValuemapToNamedParameterparam ) );
			}
			@SuppressWarnings({ "unchecked" })
			public <T> TypedQuery<X> setParameter(Parameter<T> param, T t) {
				jpaqlQuery.setParametermapToNamedParameterparam ), t );
				return this;
			}
			@SuppressWarnings({ "RedundantCast" })
			private Parameter mapToNamedParameter(Parameter criteriaParameter) {
				return jpaqlQuery.getParameter(
						explicitParameterMapping.getcriteriaParameter )
				);
			}
			@SuppressWarnings({ "unchecked" })
			public TypedQuery<X> setParameter(Parameter<CalendarparamCalendar calendarTemporalType temporalType) {
				jpaqlQuery.setParametermapToNamedParameterparam ), calendartemporalType );
				return this;
			}
			@SuppressWarnings({ "unchecked" })
			public TypedQuery<X> setParameter(Parameter<DateparamDate dateTemporalType temporalType) {
				jpaqlQuery.setParametermapToNamedParameterparam ), datetemporalType );
				return this;
			}
			public <T> T unwrap(Class<T> cls) {
				return jpaqlQuery.unwrapcls );
			}
			@SuppressWarnings({ "unchecked" })
			public Object getParameterValue(String name) {
			}
				Parameter parameter = explicitParameterNameMapping.getname );
				if ( parameter == null ) {
					throw new IllegalArgumentException"Named parameter [" + name + "] not encountered" );
				}
				return parameter;
			}
			public Parameter<?> getParameter(String name) {
			}
			@SuppressWarnings({ "unchecked" })
			public <T> Parameter<T> getParameter(String nameClass<T> type) {
				if ( type.isAssignableFromparameter.getParameterType() ) ) {
					return parameter;
				}
						"Named parameter [" + name + "] type is not assignanle to request type ["
type.getName() + "]"
				);
			}
			@SuppressWarnings({ "unchecked" })
			public TypedQuery<X> setParameter(String nameObject value) {
						value
				);
				return this;
			}
				// todo : is null valid?
				if ( value != null ) {
					if ( ! parameter.getParameterType().isInstancevalue ) ) {
								"Named parameter [" + name + "] type mismatch; expecting ["
parameter.getParameterType().getName() + "], found ["
value.getClass().getName() + "]"
						);
					}
				}
				return parameter;
			}
			@SuppressWarnings({ "unchecked" })
			public TypedQuery<X> setParameter(String nameCalendar calendarTemporalType temporalType) {
				if ( ! Calendar.class.isAssignableFromparameter.getParameterType() ) ) {
							"Named parameter [" + name + "] type mismatch; expecting ["
Calendar.class.getName() + "], found ["
parameter.getParameterType().getName() + "]"
					);
				}
				setParameterparametercalendartemporalType );
				return this;
			}
			@SuppressWarnings({ "unchecked" })
			public TypedQuery<X> setParameter(String nameDate dateTemporalType temporalType) {
				if ( ! Date.class.isAssignableFromparameter.getParameterType() ) ) {
							"Named parameter [" + name + "] type mismatch; expecting ["
Date.class.getName() + "], found ["
parameter.getParameterType().getName() + "]"
					);
				}
				setParameterparameterdatetemporalType );
				return this;
			}
			// unsupported stuff ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			public int executeUpdate() {
				throw new IllegalArgumentException"Criteria queries do not support update queries" );
			}
			public TypedQuery<X> setParameter(int iObject o) {
				throw new IllegalArgumentException"Criteria queries do not support positioned parameters" );
			}
			public TypedQuery<X> setParameter(int iCalendar calendarTemporalType temporalType) {
				throw new IllegalArgumentException"Criteria queries do not support positioned parameters" );
			}
			public TypedQuery<X> setParameter(int iDate dateTemporalType temporalType) {
				throw new IllegalArgumentException"Criteria queries do not support positioned parameters" );
			}
			public Object getParameterValue(int position) {
				throw new IllegalArgumentException"Criteria queries do not support positioned parameters" );
			}
			public Parameter<?> getParameter(int position) {
				throw new IllegalArgumentException"Criteria queries do not support positioned parameters" );
			}
			public <T> Parameter<T> getParameter(int positionClass<T> type) {
				throw new IllegalArgumentException"Criteria queries do not support positioned parameters" );
			}
		};
	}
New to GrepCode? Check out our FAQ X