HHH-14452 Support set operations in JPA Criteria API

hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java

@@ -646,7 +646,7 @@ public <T> QueryImplementor<T> createQuery(String queryString, Class<T> resultCl
 			final QueryEngine queryEngine = getFactory().getQueryEngine();
 			final QueryInterpretationCache interpretationCache = queryEngine.getInterpretationCache();
 
-			final QuerySqmImpl query = new QuerySqmImpl(
+			final QuerySqmImpl<T> query = new QuerySqmImpl<>(
 					queryString,
 					interpretationCache.resolveHqlInterpretation(
 							queryString,
@@ -940,7 +940,7 @@ public <T> QueryImplementor<T> createQuery(CriteriaQuery<T> criteriaQuery) {
 
 		try {
 			return new QuerySqmImpl<>(
-					(SqmStatement) criteriaQuery,
+					(SqmStatement<T>) criteriaQuery,
 					criteriaQuery.getResultType(),
 					this
 			);
@@ -955,7 +955,7 @@ public QueryImplementor createQuery(CriteriaUpdate criteriaUpdate) {
 		checkOpen();
 		try {
 			return new QuerySqmImpl<>(
-					(SqmUpdateStatement) criteriaUpdate,
+					(SqmUpdateStatement<?>) criteriaUpdate,
 					null,
 					this
 			);
@@ -970,7 +970,7 @@ public QueryImplementor createQuery(CriteriaDelete criteriaDelete) {
 		checkOpen();
 		try {
 			return new QuerySqmImpl<>(
-					(SqmDeleteStatement) criteriaDelete,
+					(SqmDeleteStatement<?>) criteriaDelete,
 					null,
 					this
 			);

hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java

@@ -451,8 +451,9 @@ public <T> EntityDomainType<T> resolveEntityReference(Class<T> javaType) {
 
 		// otherwise, try to handle it as a polymorphic reference
 		{
-			if ( polymorphicEntityReferenceMap.containsKey( javaType ) ) {
+			EntityDomainType<T> polymorphicDomainType = (EntityDomainType<T>) polymorphicEntityReferenceMap.get( javaType );
-				return (EntityDomainType<T>) polymorphicEntityReferenceMap.get( javaType );
+			if ( polymorphicDomainType != null ) {
+				return polymorphicDomainType;
 			}
 
 			final Set<EntityDomainType<?>> matchingDescriptors = new HashSet<>();
@@ -464,11 +465,11 @@ public <T> EntityDomainType<T> resolveEntityReference(Class<T> javaType) {
 					}
 			);
 			if ( !matchingDescriptors.isEmpty() ) {
-				final SqmPolymorphicRootDescriptor descriptor = new SqmPolymorphicRootDescriptor(
+				final SqmPolymorphicRootDescriptor<T> descriptor = new SqmPolymorphicRootDescriptor<>(
 						typeConfiguration.getJavaTypeDescriptorRegistry().resolveDescriptor( javaType ),
 						matchingDescriptors
 				);
-				polymorphicEntityReferenceMap.put( javaType, descriptor );
+				polymorphicEntityReferenceMap.putIfAbsent( javaType, descriptor );
 				return descriptor;
 			}
 		}

hibernate-core/src/main/java/org/hibernate/query/criteria/HibernateCriteriaBuilder.java

@@ -18,6 +18,7 @@
 import javax.persistence.Tuple;
 import javax.persistence.criteria.CollectionJoin;
 import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
 import javax.persistence.criteria.Expression;
 import javax.persistence.criteria.Join;
 import javax.persistence.criteria.ListJoin;
@@ -33,6 +34,7 @@
 import org.hibernate.SortOrder;
 import org.hibernate.metamodel.model.domain.DomainType;
 import org.hibernate.query.sqm.tree.expression.SqmExpression;
+import org.hibernate.query.sqm.tree.select.SqmSelectQuery;
 
 /**
  * Hibernate extensions to the JPA CriteriaBuilder.
@@ -70,6 +72,38 @@ public interface HibernateCriteriaBuilder extends CriteriaBuilder {
 
 	<T> JpaCriteriaInsertSelect<T> createCriteriaInsertSelect(Class<T> targetEntity);
 
+	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+	// Set operation
+
+	default <T> JpaCriteriaQuery<T> unionAll(CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return union( true, query1, queries );
+	}
+
+	default <T> JpaCriteriaQuery<T> union(CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return union( false, query1, queries );
+	}
+
+	<T> JpaCriteriaQuery<T> union(boolean all, CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries);
+
+	default <T> JpaCriteriaQuery<T> intersectAll(CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return intersect( true, query1, queries );
+	}
+
+	default <T> JpaCriteriaQuery<T> intersect(CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return intersect( false, query1, queries );
+	}
+
+	<T> JpaCriteriaQuery<T> intersect(boolean all, CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries);
+
+	default <T> JpaCriteriaQuery<T> exceptAll(CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return except( true, query1, queries );
+	}
+
+	default <T> JpaCriteriaQuery<T> except(CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return except( false, query1, queries );
+	}
+
+	<T> JpaCriteriaQuery<T> except(boolean all, CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries);
 
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// Paths

hibernate-core/src/main/java/org/hibernate/query/criteria/JpaCriteriaQuery.java

@@ -16,6 +16,8 @@
 import javax.persistence.criteria.Selection;
 import javax.persistence.metamodel.EntityType;
 
+import org.hibernate.FetchClauseType;
+
 /**
  * Extension of the JPA {@link CriteriaQuery}
  *
@@ -23,13 +25,34 @@
  */
 public interface JpaCriteriaQuery<T> extends CriteriaQuery<T>, JpaQueryableCriteria<T>, JpaSelectCriteria<T> {
 
+	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+	// Limit/Offset/Fetch clause
+
+	JpaExpression<Number> getOffset();
+
+	JpaCriteriaQuery<T> offset(JpaExpression<? extends Number> offset);
+
+	JpaCriteriaQuery<T> offset(Number offset);
+
+	JpaExpression<Number> getFetch();
+
+	JpaCriteriaQuery<T> fetch(JpaExpression<? extends Number> fetch);
+
+	JpaCriteriaQuery<T> fetch(JpaExpression<? extends Number> fetch, FetchClauseType fetchClauseType);
+
+	JpaCriteriaQuery<T> fetch(Number fetch);
+
+	JpaCriteriaQuery<T> fetch(Number fetch, FetchClauseType fetchClauseType);
+
+	FetchClauseType getFetchClauseType();
+
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// Accessors
 
 	@Override
 	@SuppressWarnings("unchecked")
 	default List<Order> getOrderList() {
-		return (List) getQuerySpec().getSortSpecifications();
+		return (List) getQueryPart().getSortSpecifications();
 	}
 
 	/**

hibernate-core/src/main/java/org/hibernate/query/criteria/JpaQueryGroup.java

@@ -0,0 +1,38 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later
+ * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
+ */
+package org.hibernate.query.criteria;
+
+import java.util.List;
+
+import org.hibernate.FetchClauseType;
+import org.hibernate.SetOperator;
+
+/**
+ * A query group i.e. query parts connected with a set operator.
+ *
+ * @author Christian Beikov
+ */
+public interface JpaQueryGroup<T> extends JpaQueryPart<T> {
+
+	List<? extends JpaQueryPart<T>> getQueryParts();
+
+	SetOperator getSetOperator();
+
+	void setSetOperator(SetOperator setOperator);
+
+	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+	// Covariant overrides
+
+	JpaQueryGroup<T> setSortSpecifications(List<? extends JpaOrder> sortSpecifications);
+
+	JpaQueryGroup<T> setOffset(JpaExpression<?> offset);
+
+	JpaQueryGroup<T> setFetch(JpaExpression<?> fetch);
+
+	JpaQueryGroup<T> setFetch(JpaExpression<?> fetch, FetchClauseType fetchClauseType);
+
+}

hibernate-core/src/main/java/org/hibernate/query/criteria/JpaQueryPart.java

@@ -0,0 +1,45 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later
+ * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
+ */
+package org.hibernate.query.criteria;
+
+import java.util.List;
+
+import org.hibernate.FetchClauseType;
+
+/**
+ * Models a query part i.e. the commonalities between a query group and a query specification.
+ *
+ * @see JpaQueryStructure
+ * @see JpaQueryGroup
+ *
+ * @author Christian Beikov
+ */
+public interface JpaQueryPart<T> extends JpaCriteriaNode {
+
+	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+	// Ordering clause
+
+	List<? extends JpaOrder> getSortSpecifications();
+
+	JpaQueryPart<T> setSortSpecifications(List<? extends JpaOrder> sortSpecifications);
+
+
+	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+	// Limit/Offset/Fetch clause
+
+	<X> JpaExpression<X> getOffset();
+
+	JpaQueryPart<T> setOffset(JpaExpression<?> offset);
+
+	<X> JpaExpression<X> getFetch();
+
+	JpaQueryPart<T> setFetch(JpaExpression<?> fetch);
+
+	JpaQueryPart<T> setFetch(JpaExpression<?> fetch, FetchClauseType fetchClauseType);
+
+	FetchClauseType getFetchClauseType();
+}

hibernate-core/src/main/java/org/hibernate/query/criteria/JpaQueryStructure.java

@@ -27,7 +27,7 @@
  *
  * @author Steve Ebersole
  */
-public interface JpaQueryStructure<T> extends JpaCriteriaNode {
+public interface JpaQueryStructure<T> extends JpaQueryPart<T> {
 
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// Select clause
@@ -78,27 +78,14 @@ public interface JpaQueryStructure<T> extends JpaCriteriaNode {
 
 	JpaQueryStructure<T> setGroupRestriction(Predicate... restrictions);
 
-
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	// Ordering clause
+	// Covariant overrides
-
-	List<? extends JpaOrder> getSortSpecifications();
 
 	JpaQueryStructure<T> setSortSpecifications(List<? extends JpaOrder> sortSpecifications);
 
-
-	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	// Limit/Offset/Fetch clause
-
-	<X> JpaExpression<X> getOffset();
-
 	JpaQueryStructure<T> setOffset(JpaExpression<?> offset);
 
-	<X> JpaExpression<X> getFetch();
-
 	JpaQueryStructure<T> setFetch(JpaExpression<?> fetch);
 
 	JpaQueryStructure<T> setFetch(JpaExpression<?> fetch, FetchClauseType fetchClauseType);
-
-	FetchClauseType getFetchClauseType();
 }

hibernate-core/src/main/java/org/hibernate/query/criteria/JpaSelectCriteria.java

@@ -23,6 +23,10 @@ public interface JpaSelectCriteria<T> extends AbstractQuery<T>, JpaCriteriaBase
 	 * The query structure.  See {@link JpaQueryStructure} for details
 	 */
 	JpaQueryStructure<T> getQuerySpec();
+	/**
+	 * The query structure.  See {@link JpaQueryStructure} for details
+	 */
+	JpaQueryPart<T> getQueryPart();
 
 	@Override
 	JpaSelectCriteria<T> distinct(boolean distinct);

hibernate-core/src/main/java/org/hibernate/query/hql/HqlTranslator.java

@@ -28,7 +28,7 @@ public interface HqlTranslator {
 	 *
 	 * @return The semantic representation of the incoming query.
 	 */
-	SqmStatement translate(String hql);
+	<R> SqmStatement<R> translate(String hql);
 
 	/**
 	 * Give the translator a chance to "shut down" if it needs to

hibernate-core/src/main/java/org/hibernate/query/hql/internal/QuerySplitter.java

@@ -43,6 +43,7 @@
 import org.hibernate.query.sqm.tree.from.SqmFrom;
 import org.hibernate.query.sqm.tree.from.SqmFromClause;
 import org.hibernate.query.sqm.tree.from.SqmRoot;
+import org.hibernate.query.sqm.tree.insert.SqmInsertSelectStatement;
 import org.hibernate.query.sqm.tree.predicate.SqmAndPredicate;
 import org.hibernate.query.sqm.tree.predicate.SqmBetweenPredicate;
 import org.hibernate.query.sqm.tree.predicate.SqmComparisonPredicate;
@@ -72,6 +73,7 @@
 import org.hibernate.query.sqm.tree.update.SqmAssignment;
 import org.hibernate.query.sqm.tree.update.SqmSetClause;
 import org.hibernate.query.sqm.tree.update.SqmUpdateStatement;
+import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
 
 /**
  * Handles splitting queries containing unmapped polymorphic references.
@@ -79,25 +81,25 @@
  * @author Steve Ebersole
  */
 public class QuerySplitter {
-	public static SqmSelectStatement[] split(
+	public static <R> SqmSelectStatement<R>[] split(
-			SqmSelectStatement statement,
+			SqmSelectStatement<R> statement,
 			SessionFactoryImplementor sessionFactory) {
 		// We only allow unmapped polymorphism in a very restricted way.  Specifically,
 		// the unmapped polymorphic reference can only be a root and can be the only
 		// root.  Use that restriction to locate the unmapped polymorphic reference
-		final SqmRoot unmappedPolymorphicReference = findUnmappedPolymorphicReference( statement );
+		final SqmRoot<?> unmappedPolymorphicReference = findUnmappedPolymorphicReference( statement.getQueryPart() );
 
 		if ( unmappedPolymorphicReference == null ) {
 			return new SqmSelectStatement[] { statement };
 		}
 
-		final SqmPolymorphicRootDescriptor<?> unmappedPolymorphicDescriptor = (SqmPolymorphicRootDescriptor) unmappedPolymorphicReference.getReferencedPathSource();
+		final SqmPolymorphicRootDescriptor<?> unmappedPolymorphicDescriptor = (SqmPolymorphicRootDescriptor<?>) unmappedPolymorphicReference.getReferencedPathSource();
-		final SqmSelectStatement[] expanded = new SqmSelectStatement[ unmappedPolymorphicDescriptor.getImplementors().size() ];
+		final SqmSelectStatement<R>[] expanded = new SqmSelectStatement[ unmappedPolymorphicDescriptor.getImplementors().size() ];
 
 		int i = -1;
 		for ( EntityDomainType<?> mappedDescriptor : unmappedPolymorphicDescriptor.getImplementors() ) {
 			i++;
-			final UnmappedPolymorphismReplacer replacer = new UnmappedPolymorphismReplacer(
+			final UnmappedPolymorphismReplacer<R> replacer = new UnmappedPolymorphismReplacer<>(
 					unmappedPolymorphicReference,
 					mappedDescriptor,
 					sessionFactory
@@ -108,18 +110,26 @@ public static SqmSelectStatement[] split(
 		return expanded;
 	}
 
-	private static SqmRoot findUnmappedPolymorphicReference(SqmSelectStatement statement) {
+	private static SqmRoot<?> findUnmappedPolymorphicReference(SqmQueryPart<?> queryPart) {
-		return statement.getQuerySpec()
+		if ( queryPart instanceof SqmQuerySpec<?> ) {
-				.getFromClause()
+			return ( (SqmQuerySpec<?>) queryPart ).getRoots()
-				.getRoots()
+					.stream()
-				.stream()
+					.filter( sqmRoot -> sqmRoot.getReferencedPathSource() instanceof SqmPolymorphicRootDescriptor )
-				.filter( sqmRoot -> sqmRoot.getReferencedPathSource() instanceof SqmPolymorphicRootDescriptor )
+					.findFirst()
-				.findFirst()
+					.orElse( null );
-				.orElse( null );
+		}
+		else {
+			final SqmQueryGroup<?> queryGroup = (SqmQueryGroup<?>) queryPart;
+			final SqmRoot<?> root = findUnmappedPolymorphicReference( queryGroup.getQueryParts().get( 0 ) );
+			if ( root != null ) {
+				throw new UnsupportedOperationException( "Polymorphic query group is unsupported!" );
+			}
+			return null;
+		}
 	}
 
 	@SuppressWarnings("unchecked")
-	private static class UnmappedPolymorphismReplacer extends BaseSemanticQueryWalker implements SqmCreationState {
+	private static class UnmappedPolymorphismReplacer<R> extends BaseSemanticQueryWalker implements SqmCreationState {
 		private final SqmRoot unmappedPolymorphicFromElement;
 		private final EntityDomainType mappedDescriptor;
 		private final SqmCreationContext creationContext;
@@ -139,7 +149,12 @@ private UnmappedPolymorphismReplacer(
 		}
 
 		@Override
-		public SqmUpdateStatement visitUpdateStatement(SqmUpdateStatement statement) {
+		public SqmInsertSelectStatement<R> visitInsertSelectStatement(SqmInsertSelectStatement<?> statement) {
+			throw new UnsupportedOperationException( "Not valid" );
+		}
+
+		@Override
+		public SqmUpdateStatement<R> visitUpdateStatement(SqmUpdateStatement<?> statement) {
 			throw new UnsupportedOperationException( "Not valid" );
 		}
 
@@ -154,13 +169,13 @@ public SqmAssignment visitAssignment(SqmAssignment assignment) {
 		}
 
 		@Override
-		public SqmDeleteStatement visitDeleteStatement(SqmDeleteStatement statement) {
+		public SqmDeleteStatement<R> visitDeleteStatement(SqmDeleteStatement<?> statement) {
 			throw new UnsupportedOperationException( "Not valid" );
 		}
 
 		@Override
-		public SqmSelectStatement visitSelectStatement(SqmSelectStatement statement) {
+		public SqmSelectStatement<R> visitSelectStatement(SqmSelectStatement<?> statement) {
-			final SqmSelectStatement copy = new SqmSelectStatement( statement.nodeBuilder() );
+			final SqmSelectStatement<R> copy = new SqmSelectStatement<>( statement.nodeBuilder() );
 
 			processingStateStack.push(
 					new SqmQuerySpecCreationProcessingStateStandardImpl(
@@ -180,28 +195,28 @@ public SqmSelectStatement visitSelectStatement(SqmSelectStatement statement) {
 		}
 
 		@Override
-		public SqmQueryPart visitQueryPart(SqmQueryPart<?> queryPart) {
+		public SqmQueryPart<R> visitQueryPart(SqmQueryPart<?> queryPart) {
-			return (SqmQueryPart) super.visitQueryPart( queryPart );
+			return (SqmQueryPart<R>) super.visitQueryPart( queryPart );
 		}
 
 		@Override
-		public SqmQueryGroup visitQueryGroup(SqmQueryGroup<?> queryGroup) {
+		public SqmQueryGroup<R> visitQueryGroup(SqmQueryGroup<?> queryGroup) {
 			final List<? extends SqmQueryPart<?>> queryParts = queryGroup.getQueryParts();
 			final int size = queryParts.size();
-			final List<SqmQueryPart<?>> newQueryParts = new ArrayList<>( size );
+			final List<SqmQueryPart<R>> newQueryParts = new ArrayList<>( size );
 			for ( int i = 0; i < size; i++ ) {
 				newQueryParts.add( visitQueryPart( queryParts.get( i ) ) );
 			}
-			return new SqmQueryGroup( queryGroup.nodeBuilder(), queryGroup.getSetOperator(), newQueryParts );
+			return new SqmQueryGroup<>( queryGroup.nodeBuilder(), queryGroup.getSetOperator(), newQueryParts );
 		}
 
 		@Override
-		public SqmQuerySpec visitQuerySpec(SqmQuerySpec querySpec) {
+		public SqmQuerySpec<R> visitQuerySpec(SqmQuerySpec<?> querySpec) {
 			// NOTE : it is important that we visit the SqmFromClause first so that the
 			// 		fromElementCopyMap gets built before other parts of the queryspec
 			// 		are visited
 
-			final SqmQuerySpec sqmQuerySpec = new SqmQuerySpec( querySpec.nodeBuilder() );
+			final SqmQuerySpec<R> sqmQuerySpec = new SqmQuerySpec<>( querySpec.nodeBuilder() );
 			sqmQuerySpec.setFromClause( visitFromClause( querySpec.getFromClause() ) );
 			sqmQuerySpec.setSelectClause( visitSelectClause( querySpec.getSelectClause() ) );
 			sqmQuerySpec.setWhereClause( visitWhereClause( querySpec.getWhereClause() ) );
@@ -210,12 +225,12 @@ public SqmQuerySpec visitQuerySpec(SqmQuerySpec querySpec) {
 			sqmQuerySpec.setOrderByClause( visitOrderByClause( querySpec.getOrderByClause() ) );
 			if ( querySpec.getFetchExpression() != null ) {
 				sqmQuerySpec.setFetchExpression(
-						(SqmExpression) querySpec.getFetchExpression().accept( this ),
+						(SqmExpression<?>) querySpec.getFetchExpression().accept( this ),
 						querySpec.getFetchClauseType()
 				);
 			}
 			if ( querySpec.getOffsetExpression() != null ) {
-				sqmQuerySpec.setOffsetExpression( (SqmExpression) querySpec.getOffsetExpression().accept( this ) );
+				sqmQuerySpec.setOffsetExpression( (SqmExpression<?>) querySpec.getOffsetExpression().accept( this ) );
 			}
 
 			return sqmQuerySpec;
@@ -259,24 +274,24 @@ public SqmPredicate visitHavingClause(SqmPredicate sqmPredicate) {
 		}
 
 		@Override
-		public SqmRoot visitRootPath(SqmRoot sqmRoot) {
+		public SqmRoot<?> visitRootPath(SqmRoot<?> sqmRoot) {
-			final SqmFrom sqmFrom = sqmFromCopyMap.get( sqmRoot );
+			final SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( sqmRoot );
 			if ( sqmFrom != null ) {
-				return (SqmRoot) sqmFrom;
+				return (SqmRoot<?>) sqmFrom;
 			}
-			final EntityDomainType pathSource;
+			final EntityDomainType<?> pathSource;
 			if ( sqmRoot == unmappedPolymorphicFromElement ) {
 				pathSource = mappedDescriptor;
 			}
 			else {
 				pathSource = sqmRoot.getReferencedPathSource();
 			}
-			final SqmRoot copy = new SqmRoot(
+			final SqmRoot<?> copy = new SqmRoot<>(
 					pathSource,
 					sqmRoot.getExplicitAlias(),
 					sqmRoot.nodeBuilder()
 			);
-			return (SqmRoot) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
+			return (SqmRoot<?>) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
 					copy.getNavigablePath(),
 					navigablePath -> {
 						sqmFromCopyMap.put( sqmRoot, copy );
@@ -288,16 +303,16 @@ public SqmRoot visitRootPath(SqmRoot sqmRoot) {
 		}
 
 		@Override
-		public SqmCrossJoin visitCrossJoin(SqmCrossJoin join) {
+		public SqmCrossJoin<?> visitCrossJoin(SqmCrossJoin<?> join) {
-			final SqmFrom sqmFrom = sqmFromCopyMap.get( join );
+			final SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( join );
 			if ( sqmFrom != null ) {
-				return (SqmCrossJoin) sqmFrom;
+				return (SqmCrossJoin<?>) sqmFrom;
 			}
-			return (SqmCrossJoin) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
+			return (SqmCrossJoin<?>) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
 					join.getNavigablePath(),
 					navigablePath -> {
-						final SqmRoot sqmRoot = (SqmRoot) sqmFromCopyMap.get( join.findRoot() );
+						final SqmRoot<?> sqmRoot = (SqmRoot<?>) sqmFromCopyMap.get( join.findRoot() );
-						final SqmCrossJoin copy = new SqmCrossJoin(
+						final SqmCrossJoin copy = new SqmCrossJoin<>(
 								join.getReferencedPathSource(),
 								join.getExplicitAlias(),
 								sqmRoot
@@ -311,16 +326,16 @@ public SqmCrossJoin visitCrossJoin(SqmCrossJoin join) {
 		}
 
 		@Override
-		public SqmEntityJoin visitQualifiedEntityJoin(SqmEntityJoin join) {
+		public SqmEntityJoin<?> visitQualifiedEntityJoin(SqmEntityJoin<?> join) {
-			final SqmFrom sqmFrom = sqmFromCopyMap.get( join );
+			final SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( join );
 			if ( sqmFrom != null ) {
-				return (SqmEntityJoin) sqmFrom;
+				return (SqmEntityJoin<?>) sqmFrom;
 			}
-			return (SqmEntityJoin) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
+			return (SqmEntityJoin<?>) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
 					join.getNavigablePath(),
 					navigablePath -> {
-						final SqmRoot sqmRoot = (SqmRoot) sqmFromCopyMap.get( join.findRoot() );
+						final SqmRoot<?> sqmRoot = (SqmRoot<?>) sqmFromCopyMap.get( join.findRoot() );
-						final SqmEntityJoin copy = new SqmEntityJoin(
+						final SqmEntityJoin copy = new SqmEntityJoin<>(
 								join.getReferencedPathSource(),
 								join.getExplicitAlias(),
 								join.getSqmJoinType(),
@@ -335,12 +350,12 @@ public SqmEntityJoin visitQualifiedEntityJoin(SqmEntityJoin join) {
 		}
 
 		@Override
-		public SqmAttributeJoin visitQualifiedAttributeJoin(SqmAttributeJoin join) {
+		public SqmAttributeJoin<?, ?> visitQualifiedAttributeJoin(SqmAttributeJoin<?, ?> join) {
-			SqmFrom sqmFrom = sqmFromCopyMap.get( join );
+			SqmFrom<?, ?> sqmFrom = sqmFromCopyMap.get( join );
 			if ( sqmFrom != null ) {
-				return (SqmAttributeJoin) sqmFrom;
+				return (SqmAttributeJoin<?, ?>) sqmFrom;
 			}
-			return (SqmAttributeJoin) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
+			return (SqmAttributeJoin<?, ?>) getProcessingStateStack().getCurrent().getPathRegistry().resolvePath(
 					join.getNavigablePath(),
 					navigablePath -> {
 						SqmAttributeJoin copy = join.makeCopy( getProcessingStateStack().getCurrent() );
@@ -353,13 +368,13 @@ public SqmAttributeJoin visitQualifiedAttributeJoin(SqmAttributeJoin join) {
 		}
 
 		@Override
-		public SqmBasicValuedSimplePath visitBasicValuedPath(SqmBasicValuedSimplePath path) {
+		public SqmBasicValuedSimplePath<?> visitBasicValuedPath(SqmBasicValuedSimplePath<?> path) {
 			final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
 
-			return (SqmBasicValuedSimplePath) pathRegistry.resolvePath(
+			return (SqmBasicValuedSimplePath<?>) pathRegistry.resolvePath(
 					path.getNavigablePath(),
 					navigablePath -> {
-						final SqmBasicValuedSimplePath copy = new SqmBasicValuedSimplePath(
+						final SqmBasicValuedSimplePath<?> copy = new SqmBasicValuedSimplePath<>(
 								navigablePath,
 								path.getReferencedPathSource(),
 								pathRegistry.findFromByPath( path.getLhs().getNavigablePath() ),
@@ -372,13 +387,13 @@ public SqmBasicValuedSimplePath visitBasicValuedPath(SqmBasicValuedSimplePath pa
 		}
 
 		@Override
-		public SqmEmbeddedValuedSimplePath visitEmbeddableValuedPath(SqmEmbeddedValuedSimplePath path) {
+		public SqmEmbeddedValuedSimplePath<?> visitEmbeddableValuedPath(SqmEmbeddedValuedSimplePath<?> path) {
 			final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
 
-			return (SqmEmbeddedValuedSimplePath) pathRegistry.resolvePath(
+			return (SqmEmbeddedValuedSimplePath<?>) pathRegistry.resolvePath(
 					path.getNavigablePath(),
 					navigablePath -> {
-						final SqmEmbeddedValuedSimplePath copy = new SqmEmbeddedValuedSimplePath(
+						final SqmEmbeddedValuedSimplePath<?> copy = new SqmEmbeddedValuedSimplePath<>(
 								navigablePath,
 								path.getReferencedPathSource(),
 								pathRegistry.findFromByPath( path.getLhs().getNavigablePath() ),
@@ -391,13 +406,13 @@ public SqmEmbeddedValuedSimplePath visitEmbeddableValuedPath(SqmEmbeddedValuedSi
 		}
 
 		@Override
-		public SqmEntityValuedSimplePath visitEntityValuedPath(SqmEntityValuedSimplePath path) {
+		public SqmEntityValuedSimplePath<?> visitEntityValuedPath(SqmEntityValuedSimplePath<?> path) {
 			final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
 
-			return (SqmEntityValuedSimplePath) pathRegistry.resolvePath(
+			return (SqmEntityValuedSimplePath<?>) pathRegistry.resolvePath(
 					path.getNavigablePath(),
 					navigablePath -> {
-						final SqmEntityValuedSimplePath copy = new SqmEntityValuedSimplePath(
+						final SqmEntityValuedSimplePath<?> copy = new SqmEntityValuedSimplePath<>(
 								navigablePath,
 								path.getReferencedPathSource(),
 								pathRegistry.findFromByPath( path.getLhs().getNavigablePath() ),
@@ -410,13 +425,13 @@ public SqmEntityValuedSimplePath visitEntityValuedPath(SqmEntityValuedSimplePath
 		}
 
 		@Override
-		public SqmPluralValuedSimplePath visitPluralValuedPath(SqmPluralValuedSimplePath path) {
+		public SqmPluralValuedSimplePath<?> visitPluralValuedPath(SqmPluralValuedSimplePath<?> path) {
 			final SqmPathRegistry pathRegistry = getProcessingStateStack().getCurrent().getPathRegistry();
 
-			return (SqmPluralValuedSimplePath) pathRegistry.resolvePath(
+			return (SqmPluralValuedSimplePath<?>) pathRegistry.resolvePath(
 					path.getNavigablePath(),
 					navigablePath -> {
-						final SqmPluralValuedSimplePath copy = new SqmPluralValuedSimplePath(
+						final SqmPluralValuedSimplePath<?> copy = new SqmPluralValuedSimplePath<>(
 								navigablePath,
 								path.getReferencedPathSource(),
 								pathRegistry.findFromByPath( path.getLhs().getNavigablePath() ),
@@ -431,10 +446,10 @@ public SqmPluralValuedSimplePath visitPluralValuedPath(SqmPluralValuedSimplePath
 		@Override
 		public SqmSelectClause visitSelectClause(SqmSelectClause selectClause) {
 			SqmSelectClause copy = new SqmSelectClause( selectClause.isDistinct(), selectClause.nodeBuilder() );
-			for ( SqmSelection selection : selectClause.getSelections() ) {
+			for ( SqmSelection<?> selection : selectClause.getSelections() ) {
 				copy.addSelection(
-						new SqmSelection(
+						new SqmSelection<>(
-								(SqmExpression) selection.getSelectableNode().accept( this ),
+								(SqmExpression<?>) selection.getSelectableNode().accept( this ),
 								selection.getAlias(),
 								selectClause.nodeBuilder()
 						)
@@ -444,21 +459,21 @@ public SqmSelectClause visitSelectClause(SqmSelectClause selectClause) {
 		}
 
 		@Override
-		public SqmDynamicInstantiation visitDynamicInstantiation(SqmDynamicInstantiation original) {
+		public SqmDynamicInstantiation<?> visitDynamicInstantiation(SqmDynamicInstantiation<?> original) {
-			final SqmDynamicInstantiationTarget instantiationTarget = original.getInstantiationTarget();
+			final SqmDynamicInstantiationTarget<?> instantiationTarget = original.getInstantiationTarget();
-			final SqmDynamicInstantiation copy;
+			final SqmDynamicInstantiation<?> copy;
 
 			switch ( instantiationTarget.getNature() ) {
 				case MAP: {
 					copy = SqmDynamicInstantiation.forMapInstantiation(
-							instantiationTarget.getTargetTypeDescriptor(),
+							(JavaTypeDescriptor<Map<?, ?>>) instantiationTarget.getTargetTypeDescriptor(),
 							getCreationContext().getNodeBuilder()
 					);
 					break;
 				}
 				case LIST: {
 					copy = SqmDynamicInstantiation.forListInstantiation(
-							instantiationTarget.getTargetTypeDescriptor(),
+							(JavaTypeDescriptor<List<?>>) instantiationTarget.getTargetTypeDescriptor(),
 							getCreationContext().getNodeBuilder()
 					);
 					break;
@@ -471,10 +486,10 @@ public SqmDynamicInstantiation visitDynamicInstantiation(SqmDynamicInstantiation
 				}
 			}
 
-			for ( SqmDynamicInstantiationArgument originalArgument : ( (SqmDynamicInstantiation<?>) original ).getArguments() ) {
+			for ( SqmDynamicInstantiationArgument<?> originalArgument : original.getArguments() ) {
 				copy.addArgument(
-						new SqmDynamicInstantiationArgument(
+						new SqmDynamicInstantiationArgument<>(
-								( SqmSelectableNode) originalArgument.getSelectableNode().accept( this ),
+								( SqmSelectableNode<?>) originalArgument.getSelectableNode().accept( this ),
 								originalArgument.getAlias(),
 								getCreationContext().getNodeBuilder()
 						)

hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java

@@ -212,7 +212,7 @@
  *
  * @author Steve Ebersole
  */
-public class SemanticQueryBuilder extends HqlParserBaseVisitor implements SqmCreationState {
+public class SemanticQueryBuilder<R> extends HqlParserBaseVisitor<Object> implements SqmCreationState {
 
 	private static final Logger log = Logger.getLogger( SemanticQueryBuilder.class );
 
@@ -221,11 +221,11 @@ public class SemanticQueryBuilder extends HqlParserBaseVisitor implements SqmCre
 	 * query.
 	 */
 	@SuppressWarnings("WeakerAccess")
-	public static SqmStatement buildSemanticModel(
+	public static <R> SqmStatement<R> buildSemanticModel(
 			HqlParser.StatementContext hqlParseTree,
 			SqmCreationOptions creationOptions,
 			SqmCreationContext creationContext) {
-		return new SemanticQueryBuilder( creationOptions, creationContext ).visitStatement( hqlParseTree );
+		return new SemanticQueryBuilder<R>( creationOptions, creationContext ).visitStatement( hqlParseTree );
 	}
 
 	private final SqmCreationOptions creationOptions;
@@ -271,7 +271,7 @@ protected Stack<ParameterDeclarationContext> getParameterDeclarationContextStack
 	// Grammar rules
 
 	@Override
-	public SqmStatement visitStatement(HqlParser.StatementContext ctx) {
+	public SqmStatement<R> visitStatement(HqlParser.StatementContext ctx) {
 		// parameters allow multi-valued bindings only in very limited cases, so for
 		// the base case here we say false
 		parameterDeclarationContextStack.push( () -> false );
@@ -302,9 +302,9 @@ else if ( ctx.deleteStatement() != null ) {
 	// Top-level statements
 
 	@Override
-	public SqmSelectStatement visitSelectStatement(HqlParser.SelectStatementContext ctx) {
+	public SqmSelectStatement<R> visitSelectStatement(HqlParser.SelectStatementContext ctx) {
 		final HqlParser.QueryExpressionContext queryExpressionContext = ctx.queryExpression();
-		final SqmSelectStatement selectStatement = new SqmSelectStatement( creationContext.getNodeBuilder() );
+		final SqmSelectStatement<R> selectStatement = new SqmSelectStatement<>( creationContext.getNodeBuilder() );
 
 		parameterCollector = selectStatement;
 
@@ -327,17 +327,16 @@ public SqmSelectStatement visitSelectStatement(HqlParser.SelectStatementContext
 	}
 
 	@Override
-	public SqmInsertStatement visitInsertStatement(HqlParser.InsertStatementContext ctx) {
+	public SqmInsertStatement<R> visitInsertStatement(HqlParser.InsertStatementContext ctx) {
-
+		final SqmRoot<R> root = new SqmRoot<>(
-		final SqmRoot<?> root = new SqmRoot<>(
+				(EntityDomainType<R>) visitEntityName( ctx.dmlTarget().entityName() ),
-				visitEntityName( ctx.dmlTarget().entityName() ),
 				applyJpaCompliance( visitIdentificationVariableDef( ctx.dmlTarget().identificationVariableDef() ) ),
 				creationContext.getNodeBuilder()
 		);
 
 		final HqlParser.QueryExpressionContext queryExpressionContext = ctx.queryExpression();
 		if ( queryExpressionContext != null ) {
-			final SqmInsertSelectStatement<?> insertStatement = new SqmInsertSelectStatement<>( root, creationContext.getNodeBuilder() );
+			final SqmInsertSelectStatement<R> insertStatement = new SqmInsertSelectStatement<>( root, creationContext.getNodeBuilder() );
 			parameterCollector = insertStatement;
 			final SqmDmlCreationProcessingState processingState = new SqmDmlCreationProcessingState(
 					insertStatement,
@@ -358,7 +357,7 @@ public SqmInsertStatement visitInsertStatement(HqlParser.InsertStatementContext
 				processingStateStack.push( stateFieldsProcessingState );
 				try {
 					for ( HqlParser.DotIdentifierSequenceContext stateFieldCtx : ctx.targetFieldsSpec().dotIdentifierSequence() ) {
-						final SqmPath stateField = (SqmPath) visitDotIdentifierSequence( stateFieldCtx );
+						final SqmPath<?> stateField = (SqmPath<?>) visitDotIdentifierSequence( stateFieldCtx );
 						// todo : validate each resolved stateField...
 						insertStatement.addInsertTargetStateField( stateField );
 					}
@@ -375,7 +374,7 @@ public SqmInsertStatement visitInsertStatement(HqlParser.InsertStatementContext
 
 		}
 		else {
-			final SqmInsertValuesStatement<?> insertStatement = new SqmInsertValuesStatement<>( root, creationContext.getNodeBuilder() );
+			final SqmInsertValuesStatement<R> insertStatement = new SqmInsertValuesStatement<>( root, creationContext.getNodeBuilder() );
 			parameterCollector = insertStatement;
 			final SqmDmlCreationProcessingState processingState = new SqmDmlCreationProcessingState(
 					insertStatement,
@@ -389,7 +388,7 @@ public SqmInsertStatement visitInsertStatement(HqlParser.InsertStatementContext
 				for ( HqlParser.ValuesContext values : ctx.valuesList().values() ) {
 					SqmValues sqmValues = new SqmValues();
 					for ( HqlParser.ExpressionContext expressionContext : values.expression() ) {
-						sqmValues.getExpressions().add( (SqmExpression) expressionContext.accept( this ) );
+						sqmValues.getExpressions().add( (SqmExpression<?>) expressionContext.accept( this ) );
 					}
 					insertStatement.getValuesList().add( sqmValues );
 				}
@@ -410,14 +409,14 @@ public SqmInsertStatement visitInsertStatement(HqlParser.InsertStatementContext
 	}
 
 	@Override
-	public SqmUpdateStatement visitUpdateStatement(HqlParser.UpdateStatementContext ctx) {
+	public SqmUpdateStatement<R> visitUpdateStatement(HqlParser.UpdateStatementContext ctx) {
-		final SqmRoot<?> root = new SqmRoot<>(
+		final SqmRoot<R> root = new SqmRoot<>(
-				visitEntityName( ctx.dmlTarget().entityName() ),
+				(EntityDomainType<R>) visitEntityName( ctx.dmlTarget().entityName() ),
 				visitIdentificationVariableDef( ctx.dmlTarget().identificationVariableDef() ),
 				creationContext.getNodeBuilder()
 		);
 
-		final SqmUpdateStatement<?> updateStatement = new SqmUpdateStatement<>( root, creationContext.getNodeBuilder() );
+		final SqmUpdateStatement<R> updateStatement = new SqmUpdateStatement<>( root, creationContext.getNodeBuilder() );
 		parameterCollector = updateStatement;
 		final SqmDmlCreationProcessingState processingState = new SqmDmlCreationProcessingState(
 				updateStatement,
@@ -430,7 +429,7 @@ public SqmUpdateStatement visitUpdateStatement(HqlParser.UpdateStatementContext
 			for ( HqlParser.AssignmentContext assignmentContext : ctx.setClause().assignment() ) {
 				updateStatement.applyAssignment(
 						consumeDomainPath( assignmentContext.dotIdentifierSequence() ),
-						(SqmExpression) assignmentContext.expression().accept( this )
+						(SqmExpression<?>) assignmentContext.expression().accept( this )
 				);
 			}
 
@@ -444,14 +443,14 @@ public SqmUpdateStatement visitUpdateStatement(HqlParser.UpdateStatementContext
 	}
 
 	@Override
-	public SqmDeleteStatement visitDeleteStatement(HqlParser.DeleteStatementContext ctx) {
+	public SqmDeleteStatement<R> visitDeleteStatement(HqlParser.DeleteStatementContext ctx) {
-		final SqmRoot<?> root = new SqmRoot<>(
+		final SqmRoot<R> root = new SqmRoot<>(
-				visitEntityName( ctx.dmlTarget().entityName() ),
+				(EntityDomainType<R>) visitEntityName( ctx.dmlTarget().entityName() ),
 				visitIdentificationVariableDef( ctx.dmlTarget().identificationVariableDef() ),
 				creationContext.getNodeBuilder()
 		);
 
-		final SqmDeleteStatement<?> deleteStatement = new SqmDeleteStatement<>( root, SqmQuerySource.HQL, creationContext.getNodeBuilder() );
+		final SqmDeleteStatement<R> deleteStatement = new SqmDeleteStatement<>( root, SqmQuerySource.HQL, creationContext.getNodeBuilder() );
 
 		parameterCollector = deleteStatement;
 
@@ -480,14 +479,15 @@ public SqmDeleteStatement visitDeleteStatement(HqlParser.DeleteStatementContext
 	// Query spec
 
 	@Override
-	public SqmQueryPart visitSimpleQueryGroup(HqlParser.SimpleQueryGroupContext ctx) {
+	public SqmQueryPart<Object> visitSimpleQueryGroup(HqlParser.SimpleQueryGroupContext ctx) {
-		return (SqmQueryPart) ctx.simpleQueryExpression().accept( this );
+		//noinspection unchecked
+		return (SqmQueryPart<Object>) ctx.simpleQueryExpression().accept( this );
 	}
 
 	@Override
-	public SqmQueryPart visitQuerySpecExpression(HqlParser.QuerySpecExpressionContext ctx) {
+	public SqmQueryPart<Object> visitQuerySpecExpression(HqlParser.QuerySpecExpressionContext ctx) {
 		final List<ParseTree> children = ctx.children;
-		final SqmQueryPart queryPart = visitQuerySpec( (HqlParser.QuerySpecContext) children.get( 0 ) );
+		final SqmQueryPart<Object> queryPart = visitQuerySpec( (HqlParser.QuerySpecContext) children.get( 0 ) );
 		if ( children.size() > 1 ) {
 			visitQueryOrder( queryPart, (HqlParser.QueryOrderContext) children.get( 1 ) );
 		}
@@ -495,9 +495,10 @@ public SqmQueryPart visitQuerySpecExpression(HqlParser.QuerySpecExpressionContex
 	}
 
 	@Override
-	public SqmQueryPart visitNestedQueryExpression(HqlParser.NestedQueryExpressionContext ctx) {
+	public SqmQueryPart<Object> visitNestedQueryExpression(HqlParser.NestedQueryExpressionContext ctx) {
 		final List<ParseTree> children = ctx.children;
-		final SqmQueryPart queryPart = (SqmQueryPart) children.get( 1 ).accept( this );
+		//noinspection unchecked
+		final SqmQueryPart<Object> queryPart = (SqmQueryPart<Object>) children.get( 1 ).accept( this );
 		if ( children.size() > 3 ) {
 			visitQueryOrder( queryPart, (HqlParser.QueryOrderContext) children.get( 3 ) );
 		}
@@ -505,17 +506,18 @@ public SqmQueryPart visitNestedQueryExpression(HqlParser.NestedQueryExpressionCo
 	}
 
 	@Override
-	public SqmQueryGroup<?> visitSetQueryGroup(HqlParser.SetQueryGroupContext ctx) {
+	public SqmQueryGroup<Object> visitSetQueryGroup(HqlParser.SetQueryGroupContext ctx) {
 		if ( creationOptions.useStrictJpaCompliance() ) {
 			throw new StrictJpaComplianceViolation(
 					StrictJpaComplianceViolation.Type.SET_OPERATIONS
 			);
 		}
 		final List<ParseTree> children = ctx.children;
-		final SqmQueryPart<?> firstQueryPart = (SqmQueryPart<?>) children.get( 0 ).accept( this );
+		//noinspection unchecked
-		SqmQueryGroup queryGroup;
+		final SqmQueryPart<Object> firstQueryPart = (SqmQueryPart<Object>) children.get( 0 ).accept( this );
+		SqmQueryGroup<Object> queryGroup;
 		if ( firstQueryPart instanceof SqmQueryGroup<?>) {
-			queryGroup = (SqmQueryGroup<?>) firstQueryPart;
+			queryGroup = (SqmQueryGroup<Object>) firstQueryPart;
 		}
 		else {
 			queryGroup = new SqmQueryGroup<>( firstQueryPart );
@@ -529,15 +531,15 @@ public SqmQueryGroup<?> visitSetQueryGroup(HqlParser.SetQueryGroupContext ctx) {
 			final SetOperator operator = visitSetOperator( (HqlParser.SetOperatorContext) children.get( i ) );
 			final HqlParser.SimpleQueryExpressionContext simpleQueryCtx =
 					(HqlParser.SimpleQueryExpressionContext) children.get( i + 1 );
-			final List<SqmQueryPart<?>> queryParts;
+			final List<SqmQueryPart<Object>> queryParts;
 			if ( queryGroup.getSetOperator() == null || queryGroup.getSetOperator() == operator ) {
 				queryGroup.setSetOperator( operator );
-				queryParts = queryGroup.getQueryParts();
+				queryParts = queryGroup.queryParts();
 			}
 			else {
 				queryParts = new ArrayList<>( size - ( i >> 1 ) );
 				queryParts.add( queryGroup );
-				queryGroup = new SqmQueryGroup(
+				queryGroup = new SqmQueryGroup<>(
 						creationContext.getNodeBuilder(),
 						operator,
 						queryParts
@@ -545,7 +547,7 @@ public SqmQueryGroup<?> visitSetQueryGroup(HqlParser.SetQueryGroupContext ctx) {
 				setCurrentQueryPart( queryGroup );
 			}
 
-			final SqmQueryPart<?> queryPart;
+			final SqmQueryPart<Object> queryPart;
 			try {
 				processingStateStack.push(
 						new SqmQuerySpecCreationProcessingStateStandardImpl(
@@ -556,13 +558,13 @@ public SqmQueryGroup<?> visitSetQueryGroup(HqlParser.SetQueryGroupContext ctx) {
 				);
 				final List<ParseTree> subChildren = simpleQueryCtx.children;
 				if ( subChildren.get( 0 ) instanceof HqlParser.QuerySpecContext ) {
-					final SqmQuerySpec<?> querySpec = new SqmQuerySpec<>( creationContext.getNodeBuilder() );
+					final SqmQuerySpec<Object> querySpec = new SqmQuerySpec<>( creationContext.getNodeBuilder() );
 					queryParts.add( querySpec );
 					queryPart = visitQuerySpecExpression( (HqlParser.QuerySpecExpressionContext) simpleQueryCtx );
 				}
 				else {
 					try {
-						final SqmSelectStatement selectStatement = new SqmSelectStatement( creationContext.getNodeBuilder() );
+						final SqmSelectStatement<Object> selectStatement = new SqmSelectStatement<>( creationContext.getNodeBuilder() );
 						processingStateStack.push(
 								new SqmQuerySpecCreationProcessingStateStandardImpl(
 										processingStateStack.getCurrent(),
@@ -586,7 +588,7 @@ public SqmQueryGroup<?> visitSetQueryGroup(HqlParser.SetQueryGroupContext ctx) {
 				throw new SemanticException( "All query parts must have the same arity!" );
 			}
 			for ( int j = 0; j < firstSelectionSize; j++ ) {
-				final JavaTypeDescriptor firstJavaTypeDescriptor = firstSelections.get( j ).getNodeJavaTypeDescriptor();
+				final JavaTypeDescriptor<?> firstJavaTypeDescriptor = firstSelections.get( j ).getNodeJavaTypeDescriptor();
 				if ( firstJavaTypeDescriptor != selections.get( j ).getNodeJavaTypeDescriptor() ) {
 					throw new SemanticException(
 							"Select items of the same index must have the same java type across all query parts!"
@@ -664,8 +666,9 @@ else if ( fetchClauseContext == null ) {
 	}
 
 	@Override
-	public SqmQuerySpec<?> visitQuerySpec(HqlParser.QuerySpecContext ctx) {
+	public SqmQuerySpec<Object> visitQuerySpec(HqlParser.QuerySpecContext ctx) {
-		final SqmQuerySpec<?> sqmQuerySpec = currentQuerySpec();
+		//noinspection unchecked
+		final SqmQuerySpec<Object> sqmQuerySpec = (SqmQuerySpec<Object>) currentQuerySpec();
 
 		// visit from-clause first!!!
 		treatHandlerStack.push( new TreatHandlerFromClause() );
@@ -2848,7 +2851,6 @@ private SqmLiteral<BigDecimal> bigDecimalLiteral(String text) {
 	}
 
 	private <J> BasicDomainType<J> resolveExpressableTypeBasic(Class<J> javaType) {
-		//noinspection unchecked
 		return creationContext.getJpaMetamodel().getTypeConfiguration().standardBasicTypeForJavaType( javaType );
 	}
 

hibernate-core/src/main/java/org/hibernate/query/hql/internal/StandardHqlTranslator.java

@@ -70,14 +70,14 @@ public StandardHqlTranslator(
 	}
 
 	@Override
-	public SqmStatement translate(String query) {
+	public <R> SqmStatement<R> translate(String query) {
 		HqlLogging.QUERY_LOGGER.debugf( "HQL : " + query );
 
 		final HqlParser.StatementContext hqlParseTree = parseHql( query );
 
 		// then we perform semantic analysis and build the semantic representation...
 		try {
-			final SqmStatement sqmStatement = SemanticQueryBuilder.buildSemanticModel(
+			final SqmStatement<R> sqmStatement = SemanticQueryBuilder.buildSemanticModel(
 					hqlParseTree,
 					sqmCreationOptions,
 					sqmCreationContext

hibernate-core/src/main/java/org/hibernate/query/hql/spi/HqlQueryImplementor.java

@@ -21,5 +21,5 @@ public interface HqlQueryImplementor<R> extends QueryImplementor<R>, NameableQue
 	@Override
 	ParameterMetadataImplementor getParameterMetadata();
 
-	SqmStatement getSqmStatement();
+	SqmStatement<R> getSqmStatement();
 }

hibernate-core/src/main/java/org/hibernate/query/sqm/internal/ConcreteSqmSelectQueryPlan.java

@@ -132,7 +132,7 @@ private RowTransformer<R> determineRowTransformer(
 
 		// NOTE : if we get here, a result-type of some kind (other than Object[].class) was specified
 
-		final List<SqmSelection> selections = sqm.getQuerySpec().getSelectClause().getSelections();
+		final List<SqmSelection> selections = sqm.getQueryPart().getFirstQuerySpec().getSelectClause().getSelections();
 		if ( Tuple.class.isAssignableFrom( resultType ) ) {
 			// resultType is Tuple..
 			if ( queryOptions.getTupleTransformer() == null ) {

hibernate-core/src/main/java/org/hibernate/query/sqm/internal/QuerySqmImpl.java

@@ -17,14 +17,11 @@
 import javax.persistence.PersistenceException;
 import javax.persistence.Tuple;
 
-import org.hibernate.AssertionFailure;
 import org.hibernate.HibernateException;
 import org.hibernate.LockMode;
 import org.hibernate.ScrollMode;
 import org.hibernate.cfg.NotYetImplementedException;
 import org.hibernate.engine.query.spi.EntityGraphQueryHint;
-import org.hibernate.engine.spi.QueryParameters;
-import org.hibernate.engine.spi.RowSelection;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.graph.GraphSemantic;
@@ -48,7 +45,6 @@
 import org.hibernate.query.spi.MutableQueryOptions;
 import org.hibernate.query.spi.NonSelectQueryPlan;
 import org.hibernate.query.spi.ParameterMetadataImplementor;
-import org.hibernate.query.spi.QueryImplementor;
 import org.hibernate.query.spi.QueryInterpretationCache;
 import org.hibernate.query.spi.QueryOptions;
 import org.hibernate.query.spi.QueryParameterBindings;
@@ -66,6 +62,8 @@
 import org.hibernate.query.sqm.tree.expression.SqmParameter;
 import org.hibernate.query.sqm.tree.from.SqmRoot;
 import org.hibernate.query.sqm.tree.insert.SqmInsertStatement;
+import org.hibernate.query.sqm.tree.select.SqmQueryGroup;
+import org.hibernate.query.sqm.tree.select.SqmQueryPart;
 import org.hibernate.query.sqm.tree.select.SqmQuerySpec;
 import org.hibernate.query.sqm.tree.select.SqmSelectStatement;
 import org.hibernate.query.sqm.tree.select.SqmSelection;
@@ -90,8 +88,8 @@ public class QuerySqmImpl<R>
 	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( QuerySqmImpl.class );
 
 	private final String hqlString;
-	private final SqmStatement sqmStatement;
+	private final SqmStatement<R> sqmStatement;
-	private final Class resultType;
+	private final Class<R> resultType;
 
 	private final ParameterMetadataImplementor parameterMetadata;
 	private final DomainParameterXref domainParameterXref;
@@ -168,7 +166,7 @@ protected void applyOptions(NamedHqlQueryMemento memento) {
 	public QuerySqmImpl(
 			String hqlString,
 			HqlInterpretation hqlInterpretation,
-			Class resultType,
+			Class<R> resultType,
 			SharedSessionContractImplementor producer) {
 		super( producer );
 
@@ -179,8 +177,11 @@ public QuerySqmImpl(
 
 		if ( resultType != null ) {
 			SqmUtil.verifyIsSelectStatement( sqmStatement );
-			//noinspection unchecked
+			visitQueryReturnType(
-			checkQueryReturnType( (SqmSelectStatement<R>) sqmStatement, resultType, producer.getFactory() );
+					( (SqmSelectStatement<R>) sqmStatement ).getQueryPart(),
+					resultType,
+					producer.getFactory()
+			);
 		}
 
 		this.parameterMetadata = hqlInterpretation.getParameterMetadata();
@@ -193,36 +194,17 @@ public QuerySqmImpl(
 	 * Form used for criteria queries
 	 */
 	public QuerySqmImpl(
-			SqmStatement sqmStatement,
+			SqmStatement<R> sqmStatement,
-			Class resultType,
+			Class<R> resultType,
 			SharedSessionContractImplementor producer) {
 		super( producer );
 
 		if ( sqmStatement instanceof SqmSelectStatement ) {
-			final SqmSelectStatement sqmSelectStatement = (SqmSelectStatement) sqmStatement;
+			visitQueryReturnType(
-			final SqmQuerySpec sqmQuerySpec = sqmSelectStatement.getQuerySpec();
+					( (SqmSelectStatement<R>) sqmStatement ).getQueryPart(),
-			final List<SqmSelection> sqmSelections = sqmQuerySpec.getSelectClause().getSelections();
+					resultType,
-
+					producer.getFactory()
-			// make sure there is at least one root
+			);
-			final List<SqmRoot<?>> sqmRoots = sqmQuerySpec.getFromClause().getRoots();
-			if ( sqmRoots == null || sqmRoots.isEmpty() ) {
-				throw new IllegalArgumentException( "Criteria did not define any query roots" );
-			}
-
-			if ( sqmSelections == null || sqmSelections.isEmpty() ) {
-				// if there is a single root, use that as the selection
-				if ( sqmRoots.size() == 1 ) {
-					final SqmRoot<?> sqmRoot = sqmRoots.get( 0 );
-					sqmQuerySpec.getSelectClause().add( sqmRoot, null );
-				}
-				else {
-					throw new IllegalArgumentException(  );
-				}
-			}
-
-			if ( resultType != null ) {
-				checkQueryReturnType( (SqmSelectStatement<R>) sqmStatement, resultType, producer.getFactory() );
-			}
 		}
 		else {
 			assert sqmStatement instanceof SqmDmlStatement;
@@ -255,13 +237,50 @@ public QuerySqmImpl(
 		}
 	}
 
-	private static <T> void checkQueryReturnType(SqmSelectStatement<T> sqm, Class<T> resultClass, SessionFactoryImplementor sessionFactory) {
+	private void visitQueryReturnType(
+			SqmQueryPart<R> queryPart,
+			Class<R> resultType,
+			SessionFactoryImplementor factory) {
+		if ( queryPart instanceof SqmQuerySpec<?> ) {
+			final SqmQuerySpec<R> sqmQuerySpec = (SqmQuerySpec<R>) queryPart;
+			final List<SqmSelection> sqmSelections = sqmQuerySpec.getSelectClause().getSelections();
+
+			// make sure there is at least one root
+			final List<SqmRoot<?>> sqmRoots = sqmQuerySpec.getFromClause().getRoots();
+			if ( sqmRoots == null || sqmRoots.isEmpty() ) {
+				throw new IllegalArgumentException( "Criteria did not define any query roots" );
+			}
+
+			if ( sqmSelections == null || sqmSelections.isEmpty() ) {
+				// if there is a single root, use that as the selection
+				if ( sqmRoots.size() == 1 ) {
+					final SqmRoot<?> sqmRoot = sqmRoots.get( 0 );
+					sqmQuerySpec.getSelectClause().add( sqmRoot, null );
+				}
+				else {
+					throw new IllegalArgumentException(  );
+				}
+			}
+
+			if ( resultType != null ) {
+				checkQueryReturnType( sqmQuerySpec, resultType, factory );
+			}
+		}
+		else {
+			final SqmQueryGroup<R> queryGroup = (SqmQueryGroup<R>) queryPart;
+			for ( SqmQueryPart<R> sqmQueryPart : queryGroup.getQueryParts() ) {
+				visitQueryReturnType( sqmQueryPart, resultType, factory );
+			}
+		}
+	}
+
+	private static <T> void checkQueryReturnType(SqmQuerySpec<T> querySpec, Class<T> resultClass, SessionFactoryImplementor sessionFactory) {
 		if ( resultClass == null ) {
 			// nothing to check
 			return;
 		}
 
-		final List<SqmSelection> selections = sqm.getQuerySpec().getSelectClause().getSelections();
+		final List<SqmSelection> selections = querySpec.getSelectClause().getSelections();
 
 		if ( resultClass.isArray() ) {
 			// todo (6.0) : implement
@@ -356,7 +375,7 @@ protected void applyEntityGraphQueryHint(String hintName, RootGraphImplementor e
 	}
 
 	@Override
-	public SqmStatement getSqmStatement() {
+	public SqmStatement<R> getSqmStatement() {
 		return sqmStatement;
 	}
 
@@ -465,13 +484,13 @@ protected List<R> doList() {
 		SqmUtil.verifyIsSelectStatement( getSqmStatement() );
 		getSession().prepareForQueryExecution( requiresTxn( getLockOptions().findGreatestLockMode() ) );
 		final SqmSelectStatement<?> selectStatement = (SqmSelectStatement<?>) getSqmStatement();
-		final boolean containsCollectionFetches = selectStatement.getQuerySpec().containsCollectionFetches();
+		final boolean containsCollectionFetches = selectStatement.containsCollectionFetches();
 		final boolean hasLimit = queryOptions.hasLimit();
-		final boolean needsDistincting = (
+		final boolean needsDistincting = containsCollectionFetches && (
-				selectStatement.getQuerySpec().getSelectClause().isDistinct() ||
+				selectStatement.usesDistinct() ||
 						queryOptions.getGraph() != null ||
-						hasLimit )
+						hasLimit
-				&& containsCollectionFetches;
+		);
 		ExecutionContext executionContextToUse;
 		if ( queryOptions.hasLimit() && containsCollectionFetches ) {
 			boolean fail = getSessionFactory().getSessionFactoryOptions().isFailOnPaginationOverCollectionFetchEnabled();
@@ -548,8 +567,8 @@ private SelectQueryPlan<R> resolveSelectQueryPlan() {
 	}
 
 	private SelectQueryPlan<R> buildSelectQueryPlan() {
-		final SqmSelectStatement[] concreteSqmStatements = QuerySplitter.split(
+		final SqmSelectStatement<R>[] concreteSqmStatements = QuerySplitter.split(
-				(SqmSelectStatement) getSqmStatement(),
+				(SqmSelectStatement<R>) getSqmStatement(),
 				getSessionFactory()
 		);
 
@@ -566,8 +585,8 @@ private SelectQueryPlan<R> buildSelectQueryPlan() {
 	}
 
 	@SuppressWarnings("unchecked")
-	private SelectQueryPlan<R> buildAggregatedSelectQueryPlan(SqmSelectStatement[] concreteSqmStatements) {
+	private SelectQueryPlan<R> buildAggregatedSelectQueryPlan(SqmSelectStatement<R>[] concreteSqmStatements) {
-		final SelectQueryPlan[] aggregatedQueryPlans = new SelectQueryPlan[ concreteSqmStatements.length ];
+		final SelectQueryPlan<R>[] aggregatedQueryPlans = new SelectQueryPlan[ concreteSqmStatements.length ];
 
 		// todo (6.0) : we want to make sure that certain thing (ResultListTransformer, etc) only get applied at the aggregator-level
 
@@ -583,7 +602,7 @@ private SelectQueryPlan<R> buildAggregatedSelectQueryPlan(SqmSelectStatement[] c
 	}
 
 	private SelectQueryPlan<R> buildConcreteSelectQueryPlan(
-			SqmSelectStatement concreteSqmStatement,
+			SqmSelectStatement<R> concreteSqmStatement,
 			Class<R> resultType,
 			QueryOptions queryOptions) {
 		return new ConcreteSqmSelectQueryPlan<>(
@@ -633,15 +652,15 @@ private NonSelectQueryPlan resolveNonSelectQueryPlan() {
 	private NonSelectQueryPlan buildNonSelectQueryPlan() {
 		// to get here the SQM statement has already been validated to be
 		// a non-select variety...
-		if ( getSqmStatement() instanceof SqmDeleteStatement ) {
+		if ( getSqmStatement() instanceof SqmDeleteStatement<?> ) {
 			return buildDeleteQueryPlan();
 		}
 
-		if ( getSqmStatement() instanceof SqmUpdateStatement ) {
+		if ( getSqmStatement() instanceof SqmUpdateStatement<?> ) {
 			return buildUpdateQueryPlan();
 		}
 
-		if ( getSqmStatement() instanceof SqmInsertStatement ) {
+		if ( getSqmStatement() instanceof SqmInsertStatement<?> ) {
 			return buildInsertQueryPlan();
 		}
 
@@ -649,7 +668,7 @@ private NonSelectQueryPlan buildNonSelectQueryPlan() {
 	}
 
 	private NonSelectQueryPlan buildDeleteQueryPlan() {
-		final SqmDeleteStatement sqmDelete = (SqmDeleteStatement) getSqmStatement();
+		final SqmDeleteStatement<R> sqmDelete = (SqmDeleteStatement<R>) getSqmStatement();
 
 		final String entityNameToDelete = sqmDelete.getTarget().getReferencedPathSource().getHibernateEntityName();
 		final EntityPersister entityDescriptor = getSessionFactory().getDomainModel().findEntityDescriptor( entityNameToDelete );
@@ -664,7 +683,7 @@ private NonSelectQueryPlan buildDeleteQueryPlan() {
 	}
 
 	private NonSelectQueryPlan buildUpdateQueryPlan() {
-		final SqmUpdateStatement sqmUpdate = (SqmUpdateStatement) getSqmStatement();
+		final SqmUpdateStatement<R> sqmUpdate = (SqmUpdateStatement<R>) getSqmStatement();
 
 		final String entityNameToUpdate = sqmUpdate.getTarget().getReferencedPathSource().getHibernateEntityName();
 		final EntityPersister entityDescriptor = getSessionFactory().getDomainModel().findEntityDescriptor( entityNameToUpdate );
@@ -679,7 +698,7 @@ private NonSelectQueryPlan buildUpdateQueryPlan() {
 	}
 
 	private NonSelectQueryPlan buildInsertQueryPlan() {
-		final SqmInsertStatement sqmInsert = (SqmInsertStatement) getSqmStatement();
+		final SqmInsertStatement<R> sqmInsert = (SqmInsertStatement<R>) getSqmStatement();
 
 //		final String entityNameToUpdate = sqmInsert.getTarget().getReferencedPathSource().getHibernateEntityName();
 //		final EntityPersister entityDescriptor = getSessionFactory().getDomainModel().findEntityDescriptor( entityNameToUpdate );

hibernate-core/src/main/java/org/hibernate/query/sqm/internal/SqmCriteriaNodeBuilder.java

@@ -13,6 +13,7 @@
 import java.sql.Timestamp;
 import java.time.Instant;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -21,6 +22,7 @@
 import java.util.function.Supplier;
 import javax.persistence.Tuple;
 import javax.persistence.criteria.CollectionJoin;
+import javax.persistence.criteria.CriteriaQuery;
 import javax.persistence.criteria.Expression;
 import javax.persistence.criteria.Join;
 import javax.persistence.criteria.ListJoin;
@@ -35,6 +37,7 @@
 import org.hibernate.NotYetImplementedFor6Exception;
 import org.hibernate.NullPrecedence;
 import org.hibernate.QueryException;
+import org.hibernate.SetOperator;
 import org.hibernate.SortOrder;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.internal.util.collections.ArrayHelper;
@@ -50,13 +53,17 @@
 import org.hibernate.query.UnaryArithmeticOperator;
 import org.hibernate.query.criteria.JpaCoalesce;
 import org.hibernate.query.criteria.JpaCompoundSelection;
+import org.hibernate.query.criteria.JpaCriteriaQuery;
 import org.hibernate.query.criteria.JpaExpression;
+import org.hibernate.query.criteria.JpaQueryGroup;
+import org.hibernate.query.criteria.JpaQueryPart;
 import org.hibernate.query.criteria.JpaSelection;
 import org.hibernate.query.criteria.LiteralHandlingMode;
 import org.hibernate.query.criteria.ValueHandlingMode;
 import org.hibernate.query.internal.QueryHelper;
 import org.hibernate.query.spi.QueryEngine;
 import org.hibernate.query.sqm.NodeBuilder;
+import org.hibernate.query.sqm.SqmExpressable;
 import org.hibernate.query.sqm.SqmQuerySource;
 import org.hibernate.query.sqm.function.SqmFunctionDescriptor;
 import org.hibernate.query.sqm.spi.SqmCreationContext;
@@ -100,6 +107,9 @@
 import org.hibernate.query.sqm.tree.select.SqmDynamicInstantiation;
 import org.hibernate.query.sqm.tree.select.SqmDynamicInstantiationArgument;
 import org.hibernate.query.sqm.tree.select.SqmJpaCompoundSelection;
+import org.hibernate.query.sqm.tree.select.SqmQueryGroup;
+import org.hibernate.query.sqm.tree.select.SqmQueryPart;
+import org.hibernate.query.sqm.tree.select.SqmSelectQuery;
 import org.hibernate.query.sqm.tree.select.SqmSelectStatement;
 import org.hibernate.query.sqm.tree.select.SqmSelectableNode;
 import org.hibernate.query.sqm.tree.select.SqmSortSpecification;
@@ -203,11 +213,46 @@ public <T> SqmInsertSelectStatement<T> createCriteriaInsertSelect(Class<T> targe
 	}
 
 	@Override
-	public 	<X, T> SqmExpression<X> cast(JpaExpression<T> expression, Class<X> castTargetJavaType) {
+	public <T> JpaCriteriaQuery<T> union(boolean all, CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
-		final BasicDomainType type = getTypeConfiguration().standardBasicTypeForJavaType( castTargetJavaType );
+		return setOperation( all ? SetOperator.UNION_ALL : SetOperator.UNION, query1, queries );
-		//noinspection unchecked
+	}
+
+	@Override
+	public <T> JpaCriteriaQuery<T> intersect(boolean all, CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return setOperation( all ? SetOperator.INTERSECT_ALL : SetOperator.INTERSECT, query1, queries );
+	}
+
+	@Override
+	public <T> JpaCriteriaQuery<T> except(boolean all, CriteriaQuery<? extends T> query1, CriteriaQuery<?>... queries) {
+		return setOperation( all ? SetOperator.EXCEPT_ALL : SetOperator.EXCEPT, query1, queries );
+	}
+
+	private <T> JpaCriteriaQuery<T> setOperation(
+			SetOperator operator,
+			CriteriaQuery<? extends T> query1,
+			CriteriaQuery<?>... queries) {
+		final Class<T> resultType = (Class<T>) query1.getResultType();
+		final List<SqmQueryPart<T>> queryParts = new ArrayList<>( queries.length + 1 );
+		queryParts.add( ( (SqmSelectQuery<T>) query1 ).getQueryPart() );
+		for ( CriteriaQuery<?> query : queries ) {
+			if ( query.getResultType() != resultType ) {
+				throw new IllegalArgumentException( "Result type of all operands must match!" );
+			}
+			queryParts.add( ( (SqmSelectQuery<T>) query ).getQueryPart() );
+		}
+		return new SqmSelectStatement<>(
+				new SqmQueryGroup<>( this, operator, queryParts ),
+				resultType,
+				SqmQuerySource.CRITERIA,
+				this
+		);
+	}
+
+	@Override
+	public <X, T> SqmExpression<X> cast(JpaExpression<T> expression, Class<X> castTargetJavaType) {
+		final BasicDomainType<X> type = getTypeConfiguration().standardBasicTypeForJavaType( castTargetJavaType );
 		return getFunctionDescriptor("cast").generateSqmExpression(
-				asList( (SqmTypedNode) expression, new SqmCastTarget<>( type, this ) ),
+				asList( (SqmTypedNode<?>) expression, new SqmCastTarget<>( type, this ) ),
 				type,
 				queryEngine,
 				getJpaMetamodel().getTypeConfiguration()
@@ -318,22 +363,23 @@ else if ( Map.class.equals( resultClass ) ) {
 
 	@Override
 	public <Y> JpaCompoundSelection<Y> construct(Class<Y> resultClass, List<? extends JpaSelection<?>> arguments) {
-		final SqmDynamicInstantiation instantiation;
+		final SqmDynamicInstantiation<Y> instantiation;
 		if ( List.class.equals( resultClass ) ) {
-			instantiation = SqmDynamicInstantiation.forListInstantiation( this );
+			//noinspection unchecked
+			instantiation = (SqmDynamicInstantiation<Y>) SqmDynamicInstantiation.forListInstantiation( this );
 		}
 		else if ( Map.class.equals( resultClass ) ) {
-			instantiation = SqmDynamicInstantiation.forMapInstantiation( this );
+			//noinspection unchecked
+			instantiation = (SqmDynamicInstantiation<Y>) SqmDynamicInstantiation.forMapInstantiation( this );
 		}
 		else {
 			instantiation = SqmDynamicInstantiation.forClassInstantiation( resultClass, this );
 		}
 
 		for ( Selection<?> argument : arguments ) {
-			//noinspection unchecked
 			instantiation.addArgument(
-					new SqmDynamicInstantiationArgument(
+					new SqmDynamicInstantiationArgument<>(
-							(SqmSelectableNode) argument,
+							(SqmSelectableNode<?>) argument,
 							argument.getAlias(),
 							this
 					)
@@ -348,33 +394,32 @@ else if ( Map.class.equals( resultClass ) ) {
 
 	@Override
 	public SqmSortSpecification sort(JpaExpression<?> sortExpression, SortOrder sortOrder, NullPrecedence nullPrecedence) {
-		return new SqmSortSpecification( (SqmExpression) sortExpression, sortOrder, nullPrecedence );
+		return new SqmSortSpecification( (SqmExpression<?>) sortExpression, sortOrder, nullPrecedence );
 	}
 
 	@Override
 	public SqmSortSpecification sort(JpaExpression<?> sortExpression, SortOrder sortOrder) {
-		return new SqmSortSpecification( (SqmExpression) sortExpression, sortOrder );
+		return new SqmSortSpecification( (SqmExpression<?>) sortExpression, sortOrder );
 	}
 
 	@Override
 	public SqmSortSpecification sort(JpaExpression<?> sortExpression) {
-		return new SqmSortSpecification( (SqmExpression) sortExpression );
+		return new SqmSortSpecification( (SqmExpression<?>) sortExpression );
 	}
 
 	@Override
 	public SqmSortSpecification asc(Expression<?> x) {
-		return new SqmSortSpecification( (SqmExpression) x, SortOrder.ASCENDING );
+		return new SqmSortSpecification( (SqmExpression<?>) x, SortOrder.ASCENDING );
 	}
 
 	@Override
 	public SqmSortSpecification desc(Expression<?> x) {
-		return new SqmSortSpecification( (SqmExpression) x, SortOrder.DESCENDING );
+		return new SqmSortSpecification( (SqmExpression<?>) x, SortOrder.DESCENDING );
 	}
 
 	@Override
 	public JpaCompoundSelection<Tuple> tuple(Selection<?>[] selections) {
-		//noinspection unchecked
+		return new SqmJpaCompoundSelection<>(
-		return new SqmJpaCompoundSelection(
 				ArrayHelper.toList( selections ),
 				getTypeConfiguration().getJavaTypeDescriptorRegistry().getDescriptor( Tuple.class ),
 				this
@@ -384,8 +429,8 @@ public JpaCompoundSelection<Tuple> tuple(Selection<?>[] selections) {
 	@Override
 	public JpaCompoundSelection<Tuple> tuple(List<? extends JpaSelection<?>> selections) {
 		//noinspection unchecked
-		return new SqmJpaCompoundSelection(
+		return new SqmJpaCompoundSelection<>(
-				selections,
+				(List<SqmSelectableNode<?>>) selections,
 				getTypeConfiguration().getJavaTypeDescriptorRegistry().getDescriptor( Tuple.class ),
 				this
 		);
@@ -395,7 +440,7 @@ public JpaCompoundSelection<Tuple> tuple(List<? extends JpaSelection<?>> selecti
 	public <R> SqmTuple<R> tuple(Class<R> tupleType, JpaExpression<?>... expressions) {
 		//noinspection unchecked
 		return new SqmTuple<>(
-				(List) asList( expressions ),
+				(List<SqmExpression<?>>) (List<?>) asList( expressions ),
 //				getTypeConfiguration().standardExpressableTypeForJavaType( tupleType ),
 				this
 		);
@@ -405,7 +450,7 @@ public <R> SqmTuple<R> tuple(Class<R> tupleType, JpaExpression<?>... expressions
 	public <R> SqmTuple<R> tuple(Class<R> tupleType, List<JpaExpression<?>> expressions) {
 		//noinspection unchecked
 		return new SqmTuple<>(
-				(List) expressions,
+				(List<SqmExpression<?>>) (List<?>) expressions,
 //				getTypeConfiguration().standardExpressableTypeForJavaType( tupleType ),
 				this
 		);
@@ -415,18 +460,17 @@ public <R> SqmTuple<R> tuple(Class<R> tupleType, List<JpaExpression<?>> expressi
 	public <R> SqmTuple<R> tuple(DomainType<R> tupleType, JpaExpression<?>... expressions) {
 		//noinspection unchecked
 		return new SqmTuple<>(
-				(List) asList( expressions ),
+				(List<SqmExpression<?>>) (List<?>) asList( expressions ),
 				tupleType,
 				this
 		);
 	}
 
 	@Override
-	public <R> SqmTuple<R> tuple(
+	public <R> SqmTuple<R> tuple(DomainType<R> tupleType, List<JpaExpression<?>> expressions) {
-			DomainType<R> tupleType, List<JpaExpression<?>> expressions) {
 		//noinspection unchecked
 		return new SqmTuple<>(
-				new ArrayList<>((List) expressions),
+				new ArrayList<>( (List<SqmExpression<?>>) (List<?>) expressions ),
 				tupleType,
 				this
 		);
@@ -434,8 +478,7 @@ public <R> SqmTuple<R> tuple(
 
 	@Override
 	public JpaCompoundSelection<Object[]> array(Selection<?>[] selections) {
-		//noinspection unchecked
+		return new SqmJpaCompoundSelection<>(
-		return new SqmJpaCompoundSelection(
 				ArrayHelper.toList( selections ),
 				getTypeConfiguration().getJavaTypeDescriptorRegistry().getDescriptor( Object[].class ),
 				this
@@ -445,8 +488,8 @@ public JpaCompoundSelection<Object[]> array(Selection<?>[] selections) {
 	@Override
 	public JpaCompoundSelection<Object[]> array(List<? extends JpaSelection<?>> selections) {
 		//noinspection unchecked
-		return new SqmJpaCompoundSelection(
+		return new SqmJpaCompoundSelection<>(
-				selections,
+				(List<SqmSelectableNode<?>>) selections,
 				getTypeConfiguration().getJavaTypeDescriptorRegistry().getDescriptor( Object[].class ),
 				this
 		);
@@ -455,7 +498,7 @@ public JpaCompoundSelection<Object[]> array(List<? extends JpaSelection<?>> sele
 	@Override
 	public <N extends Number> SqmExpression<Double> avg(Expression<N> argument) {
 		return getFunctionDescriptor("avg").generateSqmExpression(
-				(SqmTypedNode) argument,
+				(SqmTypedNode<?>) argument,
 				StandardBasicTypes.DOUBLE,
 				queryEngine,
 				getJpaMetamodel().getTypeConfiguration()
@@ -465,7 +508,7 @@ public <N extends Number> SqmExpression<Double> avg(Expression<N> argument) {
 	@Override
 	public <N extends Number> SqmExpression<N> sum(Expression<N> argument) {
 		return getFunctionDescriptor("sum").generateSqmExpression(
-				(SqmTypedNode) argument,
+				(SqmTypedNode<?>) argument,
 				(AllowableFunctionReturnType<N>) ( (SqmExpression<N>) argument ).getNodeType(),
 				queryEngine,
 				getJpaMetamodel().getTypeConfiguration()
@@ -484,9 +527,8 @@ public SqmExpression<Double> sumAsDouble(Expression<Float> argument) {
 
 	@Override
 	public <N extends Number> SqmExpression<N> max(Expression<N> argument) {
-		//noinspection unchecked
 		return getFunctionDescriptor("max").generateSqmExpression(
-				(SqmTypedNode) argument,
+				(SqmTypedNode<?>) argument,
 				(AllowableFunctionReturnType<N>) ((SqmExpression<N>) argument).getNodeType(),
 				queryEngine,
 				getJpaMetamodel().getTypeConfiguration()
@@ -495,9 +537,8 @@ public <N extends Number> SqmExpression<N> max(Expression<N> argument) {
 
 	@Override
 	public <N extends Number> SqmExpression<N> min(Expression<N> argument) {
-		//noinspection unchecked
 		return getFunctionDescriptor("min").generateSqmExpression(
-				(SqmTypedNode) argument,
+				(SqmTypedNode<?>) argument,
 				(AllowableFunctionReturnType<N>) ((SqmExpression<N>) argument).getNodeType(),
 				queryEngine,
 				getJpaMetamodel().getTypeConfiguration()
@@ -516,9 +557,8 @@ public <X extends Comparable<? super X>> SqmExpression<X> least(Expression<X> ar
 
 	@Override
 	public SqmExpression<Long> count(Expression<?> argument) {
-		//noinspection unchecked
 		return getFunctionDescriptor("count").generateSqmExpression(
-				(SqmTypedNode) argument,
+				(SqmTypedNode<?>) argument,
 				StandardBasicTypes.LONG,
 				queryEngine,
 				getJpaMetamodel().getTypeConfiguration()
@@ -546,9 +586,8 @@ public <N extends Number> SqmExpression<N> neg(Expression<N> x) {
 
 	@Override
 	public <N extends Number> SqmExpression<N> abs(Expression<N> x) {
-		//noinspection unchecked
 		return getFunctionDescriptor("abs").generateSqmExpression(
-				(SqmTypedNode) x,
+				(SqmTypedNode<?>) x,
 				(AllowableFunctionReturnType<N>) ((SqmExpression<N>) x).getNodeType(),
 				queryEngine,
 				getJpaMetamodel().getTypeConfiguration()
@@ -557,19 +596,19 @@ public <N extends Number> SqmExpression<N> abs(Expression<N> x) {
 
 	@Override
 	public <N extends Number> SqmExpression<N> sum(Expression<? extends N> x, Expression<? extends N> y) {
-		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, (SqmExpression) x, (SqmExpression) y );
+		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, (SqmExpression<?>) x, (SqmExpression<?>) y );
 	}
 
 	private <N extends Number> SqmExpression<N> createSqmArithmeticNode(
 			BinaryArithmeticOperator operator,
-			SqmExpression leftHandExpression,
+			SqmExpression<?> leftHandExpression,
-			SqmExpression rightHandExpression) {
+			SqmExpression<?> rightHandExpression) {
 		//noinspection unchecked
-		return new SqmBinaryArithmetic(
+		return new SqmBinaryArithmetic<>(
 				operator,
 				leftHandExpression,
 				rightHandExpression,
-				getDomainModel().getTypeConfiguration().resolveArithmeticType(
+				(SqmExpressable<N>) getDomainModel().getTypeConfiguration().resolveArithmeticType(
 						leftHandExpression.getNodeType(),
 						rightHandExpression.getNodeType(),
 						operator
@@ -580,17 +619,17 @@ private <N extends Number> SqmExpression<N> createSqmArithmeticNode(
 
 	@Override
 	public <N extends Number> SqmExpression<N> sum(Expression<? extends N> x, N y) {
-		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, (SqmExpression) x, value( y ) );
+		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, (SqmExpression<?>) x, value( y ) );
 	}
 
 	@Override
 	public <N extends Number> SqmExpression<N> sum(N x, Expression<? extends N> y) {
-		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, value( x ), (SqmExpression) y );
+		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, value( x ), (SqmExpression<?>) y );
 	}
 
 	@Override
 	public <N extends Number> SqmExpression<N> prod(Expression<? extends N> x, Expression<? extends N> y) {
-		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, value( x ), (SqmExpression) y );
+		return createSqmArithmeticNode( BinaryArithmeticOperator.ADD, value( x ), (SqmExpression<?>) y );
 	}
 
 	@Override
@@ -607,8 +646,8 @@ public <N extends Number> SqmExpression<N> prod(N x, Expression<? extends N> y)
 	public <N extends Number> SqmExpression<N> diff(Expression<? extends N> x, Expression<? extends N> y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.SUBTRACT,
-				(SqmExpression) x,
+				(SqmExpression<?>) x,
-				(SqmExpression) y
+				(SqmExpression<?>) y
 		);
 	}
 
@@ -616,7 +655,7 @@ public <N extends Number> SqmExpression<N> diff(Expression<? extends N> x, Expre
 	public <N extends Number> SqmExpression<N> diff(Expression<? extends N> x, N y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.SUBTRACT,
-				(SqmExpression) x,
+				(SqmExpression<?>) x,
 				value( y )
 		);
 	}
@@ -626,7 +665,7 @@ public <N extends Number> SqmExpression<N> diff(N x, Expression<? extends N> y)
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.SUBTRACT,
 				value( x ),
-				(SqmExpression) y
+				(SqmExpression<?>) y
 		);
 	}
 
@@ -634,8 +673,8 @@ public <N extends Number> SqmExpression<N> diff(N x, Expression<? extends N> y)
 	public SqmExpression<Number> quot(Expression<? extends Number> x, Expression<? extends Number> y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.QUOT,
-				(SqmExpression) x,
+				(SqmExpression<?>) x,
-				(SqmExpression) y
+				(SqmExpression<?>) y
 		);
 	}
 
@@ -643,7 +682,7 @@ public SqmExpression<Number> quot(Expression<? extends Number> x, Expression<? e
 	public SqmExpression<Number> quot(Expression<? extends Number> x, Number y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.QUOT,
-				(SqmExpression) x,
+				(SqmExpression<?>) x,
 				value( y )
 		);
 	}
@@ -653,7 +692,7 @@ public SqmExpression<Number> quot(Number x, Expression<? extends Number> y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.QUOT,
 				value( x ),
-				(SqmExpression) y
+				(SqmExpression<?>) y
 		);
 	}
 
@@ -661,8 +700,8 @@ public SqmExpression<Number> quot(Number x, Expression<? extends Number> y) {
 	public SqmExpression<Integer> mod(Expression<Integer> x, Expression<Integer> y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.MODULO,
-				(SqmExpression) x,
+				(SqmExpression<?>) x,
-				(SqmExpression) y
+				(SqmExpression<?>) y
 		);
 	}
 
@@ -670,7 +709,7 @@ public SqmExpression<Integer> mod(Expression<Integer> x, Expression<Integer> y)
 	public SqmExpression<Integer> mod(Expression<Integer> x, Integer y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.MODULO,
-				(SqmExpression) x,
+				(SqmExpression<?>) x,
 				value( y )
 		);
 	}
@@ -680,7 +719,7 @@ public SqmExpression<Integer> mod(Integer x, Expression<Integer> y) {
 		return createSqmArithmeticNode(
 				BinaryArithmeticOperator.MODULO,
 				value( x ),
-				(SqmExpression) y
+				(SqmExpression<?>) y
 		);
 	}
 
@@ -688,9 +727,9 @@ public SqmExpression<Integer> mod(Integer x, Expression<Integer> y) {
 	public SqmExpression<Double> sqrt(Expression<? extends Number> x) {
 		//noinspection unchecked
 		return getFunctionDescriptor("sqrt").generateSqmExpression(
-				(SqmTypedNode) x,
+				(SqmTypedNode<?>) x,
-				(AllowableFunctionReturnType) QueryHelper.highestPrecedenceType2(
+				(AllowableFunctionReturnType<Double>) QueryHelper.highestPrecedenceType2(
-						((SqmExpression) x).getNodeType(),
+						((SqmExpression<?>) x).getNodeType(),
 						StandardBasicTypes.DOUBLE
 				),
 				queryEngine,
@@ -701,55 +740,55 @@ public SqmExpression<Double> sqrt(Expression<? extends Number> x) {
 	@Override
 	@SuppressWarnings("unchecked")
 	public SqmExpression<Long> toLong(Expression<? extends Number> number) {
-		return ( (SqmExpression) number ).asLong();
+		return ( (SqmExpression<?>) number ).asLong();
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public SqmExpression<Integer> toInteger(Expression<? extends Number> number) {
-		return ( (SqmExpression) number ).asInteger();
+		return ( (SqmExpression<?>) number ).asInteger();
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public SqmExpression<Float> toFloat(Expression<? extends Number> number) {
-		return ( (SqmExpression) number ).asFloat();
+		return ( (SqmExpression<?>) number ).asFloat();
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public SqmExpression<Double> toDouble(Expression<? extends Number> number) {
-		return ( (SqmExpression) number ).asDouble();
+		return ( (SqmExpression<?>) number ).asDouble();
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public SqmExpression<BigDecimal> toBigDecimal(Expression<? extends Number> number) {
-		return ( (SqmExpression) number ).asBigDecimal();
+		return ( (SqmExpression<?>) number ).asBigDecimal();
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public SqmExpression<BigInteger> toBigInteger(Expression<? extends Number> number) {
-		return ( (SqmExpression) number ).asBigInteger();
+		return ( (SqmExpression<?>) number ).asBigInteger();
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public SqmExpression<String> toString(Expression<Character> character) {
-		return ( (SqmExpression) character ).asString();
+		return ( (SqmExpression<?>) character ).asString();
 	}
 
 	@Override
-	@SuppressWarnings("unchecked")
 	public <T> SqmLiteral<T> literal(T value) {
 		if ( value == null ) {
-			return (SqmLiteral<T>) new SqmLiteralNull( this );
+			return new SqmLiteralNull<>( this );
 		}
 
-		return new SqmLiteral(
+		//noinspection unchecked
+		return new SqmLiteral<>(
 				value,
-				getTypeConfiguration().standardBasicTypeForJavaType( value.getClass() ),
+				getTypeConfiguration().standardBasicTypeForJavaType( (Class<T>) value.getClass() ),
 				this
 		);
 	}
@@ -782,8 +821,7 @@ public <T> List<? extends SqmExpression<T>> literals(List<T> values) {
 
 	@Override
 	public <T> SqmExpression<T> nullLiteral(Class<T> resultClass) {
-		//noinspection unchecked
+		return new SqmLiteralNull<>( getTypeConfiguration().standardBasicTypeForJavaType( resultClass ), this );
-		return new SqmLiteralNull( getTypeConfiguration().standardBasicTypeForJavaType( resultClass ), this );
 	}
 
 	class MultiValueParameterType<T> implements AllowableParameterType<T> {

hibernate-core/src/main/java/org/hibernate/query/sqm/spi/BaseSemanticQueryWalker.java

@@ -122,12 +122,14 @@ public Object visitStatement(SqmStatement<?> sqmStatement) {
 
 	@Override
 	public Object visitSelectStatement(SqmSelectStatement<?> statement) {
+		visitCteContainer( statement );
 		visitQueryPart( statement.getQueryPart() );
 		return statement;
 	}
 
 	@Override
 	public Object visitUpdateStatement(SqmUpdateStatement<?> statement) {
+		visitCteContainer( statement );
 		visitRootPath( statement.getTarget() );
 		visitSetClause( statement.getSetClause() );
 		visitWhereClause( statement.getWhereClause() );
@@ -151,6 +153,7 @@ public Object visitAssignment(SqmAssignment assignment) {
 
 	@Override
 	public Object visitInsertSelectStatement(SqmInsertSelectStatement<?> statement) {
+		visitCteContainer( statement );
 		visitRootPath( statement.getTarget() );
 		for ( SqmPath<?> stateField : statement.getInsertionTargetPaths() ) {
 			stateField.accept( this );
@@ -161,6 +164,7 @@ public Object visitInsertSelectStatement(SqmInsertSelectStatement<?> statement)
 
 	@Override
 	public Object visitInsertValuesStatement(SqmInsertValuesStatement<?> statement) {
+		visitCteContainer( statement );
 		visitRootPath( statement.getTarget() );
 		for ( SqmPath<?> stateField : statement.getInsertionTargetPaths() ) {
 			stateField.accept( this );
@@ -173,6 +177,7 @@ public Object visitInsertValuesStatement(SqmInsertValuesStatement<?> statement)
 
 	@Override
 	public Object visitDeleteStatement(SqmDeleteStatement<?> statement) {
+		visitCteContainer( statement );
 		visitRootPath( statement.getTarget() );
 		visitWhereClause( statement.getWhereClause() );
 		return statement;
@@ -200,8 +205,11 @@ public Object visitQueryPart(SqmQueryPart<?> queryPart) {
 	@Override
 	public Object visitQueryGroup(SqmQueryGroup<?> queryGroup) {
 		for ( SqmQueryPart<?> queryPart : queryGroup.getQueryParts() ) {
-			visitQueryPart( queryPart );
+			queryPart.accept( this );
 		}
+		visitOrderByClause( queryGroup.getOrderByClause() );
+		visitOffsetExpression( queryGroup.getOffsetExpression() );
+		visitFetchExpression( queryGroup.getFetchExpression() );
 		return queryGroup;
 	}
 
@@ -210,6 +218,8 @@ public Object visitQuerySpec(SqmQuerySpec<?> querySpec) {
 		visitFromClause( querySpec.getFromClause() );
 		visitSelectClause( querySpec.getSelectClause() );
 		visitWhereClause( querySpec.getWhereClause() );
+		visitGroupByClause( querySpec.getGroupByClauseExpressions() );
+		visitHavingClause( querySpec.getHavingClausePredicate() );
 		visitOrderByClause( querySpec.getOrderByClause() );
 		visitOffsetExpression( querySpec.getOffsetExpression() );
 		visitFetchExpression( querySpec.getFetchExpression() );
@@ -228,7 +238,6 @@ public Object visitRootPath(SqmRoot<?> sqmRoot) {
 		return sqmRoot;
 	}
 
-
 	@Override
 	public Object visitCrossJoin(SqmCrossJoin<?> joinedFromElement) {
 		joinedFromElement.visitSqmJoins( sqmJoin -> sqmJoin.accept( this ) );
@@ -323,7 +332,7 @@ public Object visitSelection(SqmSelection selection) {
 
 	@Override
 	public Object visitValues(SqmValues values) {
-		for ( SqmExpression expression : values.getExpressions() ) {
+		for ( SqmExpression<?> expression : values.getExpressions() ) {
 			expression.accept( this );
 		}
 		return values;
@@ -409,7 +418,7 @@ public Object visitNegatedPredicate(SqmNegatedPredicate predicate) {
 	@Override
 	public Object visitInListPredicate(SqmInListPredicate<?> predicate) {
 		predicate.getTestExpression().accept( this );
-		for ( SqmExpression expression : predicate.getListExpressions() ) {
+		for ( SqmExpression<?> expression : predicate.getListExpressions() ) {
 			expression.accept( this );
 		}
 		return predicate;
@@ -473,6 +482,9 @@ public Object visitGroupByClause(List<SqmExpression<?>> groupByClauseExpressions
 
 	@Override
 	public Object visitHavingClause(SqmPredicate sqmPredicate) {
+		if ( sqmPredicate == null ) {
+			return null;
+		}
 		return sqmPredicate.accept( this );
 	}
 

hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java

@@ -348,7 +348,8 @@ public BaseSqmToSqlAstConverter(
 
 		if ( statement instanceof SqmSelectStatement<?> ) {
 			this.domainResults = new ArrayList<>(
-					( (SqmSelectStatement<?>) statement ).getQuerySpec()
+					( (SqmSelectStatement<?>) statement ).getQueryPart()
+							.getFirstQuerySpec()
 							.getSelectClause()
 							.getSelectionItems()
 							.size()
@@ -507,6 +508,7 @@ public Stack<Clause> getCurrentClauseStack() {
 	@Override
 	public SqmTranslation<T> translate() {
 		final SqmStatement<?> sqmStatement = getStatement();
+		//noinspection unchecked
 		final T statement = (T) sqmStatement.accept( this );
 		return new StandardSqmTranslation<>(
 				statement,
@@ -924,8 +926,7 @@ public InsertStatement visitInsertValuesStatement(SqmInsertValuesStatement<?> sq
 	@Override
 	public Values visitValues(SqmValues sqmValues) {
 		Values values = new Values();
-		//noinspection rawtypes
+		for ( SqmExpression<?> expression : sqmValues.getExpressions() ) {
-		for ( SqmExpression expression : sqmValues.getExpressions() ) {
 			values.getExpressions().add( (Expression) expression.accept( this ) );
 		}
 		return values;

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/LiteralHelper.java

@@ -29,7 +29,6 @@ public static SqmLiteral<Timestamp> timestampLiteralFrom(String literalText, Sqm
 				LocalDateTime.from( JdbcTimestampTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) )
 		);
 
-		//noinspection unchecked
 		return new SqmLiteral<>(
 				literal,
 				creationState.getCreationContext().getJpaMetamodel().getTypeConfiguration().standardBasicTypeForJavaType( Timestamp.class ),
@@ -58,7 +57,6 @@ public static SqmLiteral<Date> dateLiteralFrom(String literalText, SqmCreationSt
 		final LocalDate localDate = LocalDate.from( JdbcDateTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) );
 		final Date literal = new Date( localDate.toEpochDay() );
 
-		//noinspection unchecked
 		return new SqmLiteral<>(
 				literal,
 				creationState.getCreationContext().getJpaMetamodel().getTypeConfiguration().standardBasicTypeForJavaType( Date.class ),
@@ -70,7 +68,6 @@ public static SqmLiteral<Time> timeLiteralFrom(String literalText, SqmCreationSt
 		final LocalTime localTime = LocalTime.from( JdbcTimeTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) );
 		final Time literal = Time.valueOf( localTime );
 
-		//noinspection unchecked
 		return new SqmLiteral<>(
 				literal,
 				creationState.getCreationContext().getJpaMetamodel().getTypeConfiguration().standardBasicTypeForJavaType( Time.class ),

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/insert/SqmValues.java

@@ -15,9 +15,9 @@
  * @author Gavin King
  */
 public class SqmValues {
-	private List<SqmExpression> expressions = new ArrayList<>();
+	private final List<SqmExpression<?>> expressions = new ArrayList<>();
 
-	public List<SqmExpression> getExpressions() {
+	public List<SqmExpression<?>> getExpressions() {
 		return expressions;
 	}
 }

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/jpa/AbstractJpaTupleElement.java

@@ -62,13 +62,13 @@ public SqmExpressable<T> getNodeType() {
 
 	protected final void setExpressableType(SqmExpressable<?> expressableType) {
 		//noinspection unchecked
-		this.expressableType = (SqmExpressable) expressableType;
+		this.expressableType = (SqmExpressable<T>) expressableType;
 	}
 
 	/**
 	 * Protected access to set the JavaTypeDescriptor via Java Class
 	 */
-	protected void setJavaType(Class targetType) {
+	protected void setJavaType(Class<T> targetType) {
 		if ( targetType != null ) {
 			setExpressableType(
 					nodeBuilder().getDomainModel()

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiation.java

@@ -35,67 +35,65 @@
 public class SqmDynamicInstantiation<T>
 		extends AbstractJpaSelection<T>
 		implements SqmSelectableNode<T>,
-		SqmAliasedExpressionContainer<SqmDynamicInstantiationArgument>,
+		SqmAliasedExpressionContainer<SqmDynamicInstantiationArgument<?>>,
 		JpaCompoundSelection<T>,
 		DomainResultProducer<T> {
 
 	private static final Logger log = Logger.getLogger( SqmDynamicInstantiation.class );
 
-	public static SqmDynamicInstantiation forClassInstantiation(
+	public static <R> SqmDynamicInstantiation<R> forClassInstantiation(
-			JavaTypeDescriptor targetJavaType,
+			JavaTypeDescriptor<R> targetJavaType,
 			NodeBuilder nodeBuilder) {
-		//noinspection unchecked
+		return new SqmDynamicInstantiation<>(
-		return new SqmDynamicInstantiation(
+				new DynamicInstantiationTargetImpl<>( CLASS, targetJavaType ),
-				new DynamicInstantiationTargetImpl( CLASS, targetJavaType ),
 				nodeBuilder
 		);
 	}
 
-	public static SqmDynamicInstantiation forClassInstantiation(
+	public static <R> SqmDynamicInstantiation<R> forClassInstantiation(
-			Class targetJavaType,
+			Class<R> targetJavaType,
 			NodeBuilder nodeBuilder) {
-		//noinspection unchecked
 		return forClassInstantiation(
 				nodeBuilder.getTypeConfiguration().getJavaTypeDescriptorRegistry().getDescriptor( targetJavaType ),
 				nodeBuilder
 		);
 	}
 
-	public static SqmDynamicInstantiation forMapInstantiation(
+	public static <M extends Map<?, ?>> SqmDynamicInstantiation<M> forMapInstantiation(
-			JavaTypeDescriptor<Map> mapJavaTypeDescriptor,
+			JavaTypeDescriptor<M> mapJavaTypeDescriptor,
 			NodeBuilder nodeBuilder) {
-		//noinspection unchecked
+		return new SqmDynamicInstantiation<>(
-		return new SqmDynamicInstantiation(
+				new DynamicInstantiationTargetImpl<>( MAP, mapJavaTypeDescriptor ),
-				new DynamicInstantiationTargetImpl( MAP, mapJavaTypeDescriptor ),
 				nodeBuilder
 		);
 	}
 
-	public static SqmDynamicInstantiation forMapInstantiation(NodeBuilder nodeBuilder) {
+	public static <M extends Map<?, ?>> SqmDynamicInstantiation<M> forMapInstantiation(NodeBuilder nodeBuilder) {
-		return forMapInstantiation(
+		//noinspection unchecked
+		return (SqmDynamicInstantiation<M>) (SqmDynamicInstantiation<?>) forMapInstantiation(
 				nodeBuilder.getTypeConfiguration().getJavaTypeDescriptorRegistry().getDescriptor( Map.class ),
 				nodeBuilder
 		);
 	}
 
-	public static SqmDynamicInstantiation forListInstantiation(
+	public static <L extends List<?>> SqmDynamicInstantiation<L> forListInstantiation(
-			JavaTypeDescriptor<List> listJavaTypeDescriptor,
+			JavaTypeDescriptor<L> listJavaTypeDescriptor,
 			NodeBuilder nodeBuilder) {
-		//noinspection unchecked
+		return new SqmDynamicInstantiation<>(
-		return new SqmDynamicInstantiation(
+				new DynamicInstantiationTargetImpl<>( LIST, listJavaTypeDescriptor ),
-				new DynamicInstantiationTargetImpl( LIST, listJavaTypeDescriptor ),
 				nodeBuilder
 		);
 	}
 
-	public static SqmDynamicInstantiation forListInstantiation(NodeBuilder nodeBuilder) {
+	public static <L extends List<?>> SqmDynamicInstantiation<L> forListInstantiation(NodeBuilder nodeBuilder) {
-		return forListInstantiation(
+		//noinspection unchecked
+		return (SqmDynamicInstantiation<L>) (SqmDynamicInstantiation<?>) forListInstantiation(
 				nodeBuilder.getTypeConfiguration().getJavaTypeDescriptorRegistry().getDescriptor( List.class ),
 				nodeBuilder
 		);
 	}
 
-	private final SqmDynamicInstantiationTarget <T>instantiationTarget;
+	private final SqmDynamicInstantiationTarget <T> instantiationTarget;
 	private List<SqmDynamicInstantiationArgument<?>> arguments;
 
 	private SqmDynamicInstantiation(
@@ -123,7 +121,7 @@ public String asLoggableText() {
 		return "<new " + instantiationTarget.getJavaType().getName() + ">";
 	}
 
-	public void addArgument(SqmDynamicInstantiationArgument argument) {
+	public void addArgument(SqmDynamicInstantiationArgument<?> argument) {
 		if ( instantiationTarget.getNature() == LIST ) {
 			// really should not have an alias...
 			if ( argument.getAlias() != null && log.isDebugEnabled() ) {
@@ -153,8 +151,8 @@ else if ( instantiationTarget.getNature() == MAP ) {
 	}
 
 	@Override
-	public SqmDynamicInstantiationArgument add(SqmExpression<?> expression, String alias) {
+	public SqmDynamicInstantiationArgument<?> add(SqmExpression<?> expression, String alias) {
-		final SqmDynamicInstantiationArgument argument = new SqmDynamicInstantiationArgument<>(
+		final SqmDynamicInstantiationArgument<?> argument = new SqmDynamicInstantiationArgument<>(
 				expression,
 				alias,
 				nodeBuilder()
@@ -164,7 +162,7 @@ public SqmDynamicInstantiationArgument add(SqmExpression<?> expression, String a
 	}
 
 	@Override
-	public void add(SqmDynamicInstantiationArgument aliasExpression) {
+	public void add(SqmDynamicInstantiationArgument<?> aliasExpression) {
 		addArgument( aliasExpression );
 	}
 
@@ -210,7 +208,7 @@ public JavaTypeDescriptor<T> getExpressableJavaTypeDescriptor() {
 
 	@Override
 	public void visitSubSelectableNodes(Consumer<SqmSelectableNode<?>> consumer) {
-		for ( SqmDynamicInstantiationArgument argument : arguments ) {
+		for ( SqmDynamicInstantiationArgument<?> argument : arguments ) {
 			consumer.accept( argument.getSelectableNode() );
 		}
 	}

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmQueryGroup.java

@@ -6,10 +6,16 @@
  */
 package org.hibernate.query.sqm.tree.select;
 
+import java.util.Collections;
 import java.util.List;
 
+import org.hibernate.FetchClauseType;
 import org.hibernate.SetOperator;
 import org.hibernate.internal.util.collections.CollectionHelper;
+import org.hibernate.query.criteria.JpaExpression;
+import org.hibernate.query.criteria.JpaOrder;
+import org.hibernate.query.criteria.JpaQueryGroup;
+import org.hibernate.query.criteria.JpaQueryPart;
 import org.hibernate.query.sqm.NodeBuilder;
 import org.hibernate.query.sqm.SemanticQueryWalker;
 
@@ -18,7 +24,7 @@
  *
  * @author Christian Beikov
  */
-public class SqmQueryGroup<T> extends SqmQueryPart<T> {
+public class SqmQueryGroup<T> extends SqmQueryPart<T> implements JpaQueryGroup<T> {
 
 	private final List<SqmQueryPart<T>> queryParts;
 	private SetOperator setOperator;
@@ -36,6 +42,10 @@ public SqmQueryGroup(
 		this.queryParts = queryParts;
 	}
 
+	public List<SqmQueryPart<T>> queryParts() {
+		return queryParts;
+	}
+
 	@Override
 	public SqmQuerySpec<T> getFirstQuerySpec() {
 		return queryParts.get( 0 ).getFirstQuerySpec();
@@ -56,15 +66,41 @@ public <X> X accept(SemanticQueryWalker<X> walker) {
 		return walker.visitQueryGroup( this );
 	}
 
+	@Override
 	public List<SqmQueryPart<T>> getQueryParts() {
-		return queryParts;
+		return Collections.unmodifiableList( queryParts );
 	}
 
+	@Override
 	public SetOperator getSetOperator() {
 		return setOperator;
 	}
 
+	@Override
 	public void setSetOperator(SetOperator setOperator) {
+		if ( setOperator == null ) {
+			throw new IllegalArgumentException();
+		}
 		this.setOperator = setOperator;
 	}
+
+	@Override
+	public SqmQueryGroup<T> setSortSpecifications(List<? extends JpaOrder> sortSpecifications) {
+		return (SqmQueryGroup<T>) super.setSortSpecifications( sortSpecifications );
+	}
+
+	@Override
+	public SqmQueryGroup<T> setOffset(JpaExpression<?> offset) {
+		return (SqmQueryGroup<T>) super.setOffset( offset );
+	}
+
+	@Override
+	public SqmQueryGroup<T> setFetch(JpaExpression<?> fetch) {
+		return (SqmQueryGroup<T>) super.setFetch( fetch );
+	}
+
+	@Override
+	public SqmQueryGroup<T> setFetch(JpaExpression<?> fetch, FetchClauseType fetchClauseType) {
+		return (SqmQueryGroup<T>) super.setFetch( fetch, fetchClauseType );
+	}
 }

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmQueryPart.java

@@ -12,6 +12,7 @@
 import org.hibernate.FetchClauseType;
 import org.hibernate.query.criteria.JpaExpression;
 import org.hibernate.query.criteria.JpaOrder;
+import org.hibernate.query.criteria.JpaQueryPart;
 import org.hibernate.query.sqm.NodeBuilder;
 import org.hibernate.query.sqm.tree.SqmVisitableNode;
 import org.hibernate.query.sqm.tree.expression.SqmExpression;
@@ -22,7 +23,7 @@
  *
  * @author Christian Beikov
  */
-public abstract class SqmQueryPart<T> implements SqmVisitableNode {
+public abstract class SqmQueryPart<T> implements SqmVisitableNode, JpaQueryPart<T> {
 	private final NodeBuilder nodeBuilder;
 
 	private SqmOrderByClause orderByClause;
@@ -88,6 +89,7 @@ public void setFetchExpression(SqmExpression<?> fetchExpression, FetchClauseType
 		}
 	}
 
+	@Override
 	public FetchClauseType getFetchClauseType() {
 		return fetchClauseType;
 	}
@@ -95,6 +97,7 @@ public FetchClauseType getFetchClauseType() {
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// JPA
 
+	@Override
 	public List<SqmSortSpecification> getSortSpecifications() {
 		if ( getOrderByClause() == null ) {
 			return Collections.emptyList();
@@ -103,6 +106,7 @@ public List<SqmSortSpecification> getSortSpecifications() {
 		return getOrderByClause().getSortSpecifications();
 	}
 
+	@Override
 	public SqmQueryPart<T> setSortSpecifications(List<? extends JpaOrder> sortSpecifications) {
 		if ( getOrderByClause() == null ) {
 			setOrderByClause( new SqmOrderByClause() );
@@ -115,22 +119,32 @@ public SqmQueryPart<T> setSortSpecifications(List<? extends JpaOrder> sortSpecif
 	}
 
 	@SuppressWarnings("unchecked")
+	@Override
 	public SqmExpression<?> getOffset() {
 		return getOffsetExpression();
 	}
 
+	@Override
 	public SqmQueryPart<T> setOffset(JpaExpression<?> offset) {
 		setOffsetExpression( (SqmExpression<?>) offset );
 		return this;
 	}
 
 	@SuppressWarnings("unchecked")
+	@Override
 	public SqmExpression<?> getFetch() {
 		return getFetchExpression();
 	}
 
+	@Override
 	public SqmQueryPart<T> setFetch(JpaExpression<?> fetch) {
 		setFetchExpression( (SqmExpression<?>) fetch );
 		return this;
 	}
+
+	@Override
+	public JpaQueryPart<T> setFetch(JpaExpression<?> fetch, FetchClauseType fetchClauseType) {
+		setFetchExpression( (SqmExpression<?>) fetch, fetchClauseType );
+		return this;
+	}
 }

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmSelectStatement.java

@@ -21,8 +21,10 @@
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Selection;
 
+import org.hibernate.FetchClauseType;
 import org.hibernate.internal.util.collections.CollectionHelper;
 import org.hibernate.query.criteria.JpaCriteriaQuery;
+import org.hibernate.query.criteria.JpaExpression;
 import org.hibernate.query.criteria.JpaSelection;
 import org.hibernate.query.sqm.NodeBuilder;
 import org.hibernate.query.sqm.SemanticQueryWalker;
@@ -58,6 +60,15 @@ public SqmSelectStatement(Class<T> resultJavaType, SqmQuerySource querySource, N
 		this.querySource = querySource;
 	}
 
+	public SqmSelectStatement(
+			SqmQueryPart<T> queryPart,
+			Class<T> resultType,
+			SqmQuerySource querySource,
+			NodeBuilder builder) {
+		super( queryPart, resultType, builder );
+		this.querySource = querySource;
+	}
+
 	/**
 	 * @implNote This form is used from Hibernate's JPA criteria handling.
 	 */
@@ -75,6 +86,52 @@ public SqmQuerySource getQuerySource() {
 		return querySource;
 	}
 
+	@Override
+	public SqmQuerySpec<T> getQuerySpec() {
+		if ( querySource == SqmQuerySource.CRITERIA ) {
+			final SqmQueryPart<T> queryPart = getQueryPart();
+			if ( queryPart instanceof SqmQuerySpec<?> ) {
+				return (SqmQuerySpec<T>) queryPart;
+			}
+			throw new IllegalStateException(
+					"Query group can't be treated as query spec. Use JpaSelectCriteria#getQueryPart to access query group details"
+			);
+		}
+		else {
+			return super.getQuerySpec();
+		}
+	}
+
+	public boolean containsCollectionFetches() {
+		return containsCollectionFetches( getQueryPart() );
+	}
+
+	private boolean containsCollectionFetches(SqmQueryPart<?> queryPart) {
+		if ( queryPart instanceof SqmQuerySpec<?> ) {
+			return ( (SqmQuerySpec<?>) queryPart ).containsCollectionFetches();
+		}
+		else {
+			// We only have to check the first one
+			final SqmQueryGroup<?> queryGroup = (SqmQueryGroup<?>) queryPart;
+			return containsCollectionFetches( queryGroup.getQueryParts().get( 0 ) );
+		}
+	}
+
+	public boolean usesDistinct() {
+		return usesDistinct( getQueryPart() );
+	}
+
+	private boolean usesDistinct(SqmQueryPart<?> queryPart) {
+		if ( queryPart instanceof SqmQuerySpec<?> ) {
+			return ( (SqmQuerySpec<?>) queryPart ).getSelectClause().isDistinct();
+		}
+		else {
+			// We only have to check the first one
+			final SqmQueryGroup<?> queryGroup = (SqmQueryGroup<?>) queryPart;
+			return usesDistinct( queryGroup.getQueryParts().get( 0 ) );
+		}
+	}
+
 	@Override
 	public Set<SqmParameter<?>> getSqmParameters() {
 		if ( querySource == SqmQuerySource.CRITERIA ) {
@@ -265,7 +322,7 @@ public SqmSelectStatement<T> select(Selection<? extends T> selection) {
 	@Override
 	public SqmSelectStatement<T> multiselect(Selection<?>... selections) {
 		for ( Selection<?> selection : selections ) {
-			getQuerySpec().getSelectClause().add( (SqmExpression) selection, selection.getAlias() );
+			getQuerySpec().getSelectClause().add( (SqmExpression<?>) selection, selection.getAlias() );
 		}
 		setResultType( (Class<T>) Object[].class );
 		return this;
@@ -274,7 +331,7 @@ public SqmSelectStatement<T> multiselect(Selection<?>... selections) {
 	@Override
 	public SqmSelectStatement<T> multiselect(List<Selection<?>> selectionList) {
 		for ( Selection<?> selection : selectionList ) {
-			getQuerySpec().getSelectClause().add( (SqmExpression) selection, selection.getAlias() );
+			getQuerySpec().getSelectClause().add( (SqmExpression<?>) selection, selection.getAlias() );
 		}
 		setResultType( (Class<T>) Object[].class );
 		return this;
@@ -282,22 +339,22 @@ public SqmSelectStatement<T> multiselect(List<Selection<?>> selectionList) {
 
 	@Override
 	public SqmSelectStatement<T> orderBy(Order... orders) {
-		if ( getQuerySpec().getOrderByClause() == null ) {
+		if ( getQueryPart().getOrderByClause() == null ) {
-			getQuerySpec().setOrderByClause( new SqmOrderByClause() );
+			getQueryPart().setOrderByClause( new SqmOrderByClause() );
 		}
 		for ( Order order : orders ) {
-			getQuerySpec().getOrderByClause().addSortSpecification( (SqmSortSpecification) order );
+			getQueryPart().getOrderByClause().addSortSpecification( (SqmSortSpecification) order );
 		}
 		return this;
 	}
 
 	@Override
 	public SqmSelectStatement<T> orderBy(List<Order> orders) {
-		if ( getQuerySpec().getOrderByClause() == null ) {
+		if ( getQueryPart().getOrderByClause() == null ) {
-			getQuerySpec().setOrderByClause( new SqmOrderByClause() );
+			getQueryPart().setOrderByClause( new SqmOrderByClause() );
 		}
 		for ( Order order : orders ) {
-			getQuerySpec().getOrderByClause().addSortSpecification( (SqmSortSpecification) order );
+			getQueryPart().getOrderByClause().addSortSpecification( (SqmSortSpecification) order );
 		}
 		return this;
 	}
@@ -336,4 +393,55 @@ public SqmSelectStatement<T> having(Expression<Boolean> booleanExpression) {
 	public SqmSelectStatement<T> having(Predicate... predicates) {
 		return (SqmSelectStatement<T>) super.having( predicates );
 	}
+
+	@Override
+	public JpaExpression<Number> getOffset() {
+		return (JpaExpression<Number>) getQueryPart().getOffset();
+	}
+
+	@Override
+	public JpaCriteriaQuery<T> offset(JpaExpression<? extends Number> offset) {
+		getQueryPart().setOffset( offset );
+		return this;
+	}
+
+	@Override
+	public JpaCriteriaQuery<T> offset(Number offset) {
+		getQueryPart().setOffset( nodeBuilder().value( offset ) );
+		return this;
+	}
+
+	@Override
+	public JpaExpression<Number> getFetch() {
+		return (JpaExpression<Number>) getQueryPart().getFetch();
+	}
+
+	@Override
+	public JpaCriteriaQuery<T> fetch(JpaExpression<? extends Number> fetch) {
+		getQueryPart().setFetch( fetch );
+		return this;
+	}
+
+	@Override
+	public JpaCriteriaQuery<T> fetch(JpaExpression<? extends Number> fetch, FetchClauseType fetchClauseType) {
+		getQueryPart().setFetch( fetch, fetchClauseType );
+		return this;
+	}
+
+	@Override
+	public JpaCriteriaQuery<T> fetch(Number fetch) {
+		getQueryPart().setFetch( nodeBuilder().value( fetch ) );
+		return this;
+	}
+
+	@Override
+	public JpaCriteriaQuery<T> fetch(Number fetch, FetchClauseType fetchClauseType) {
+		getQueryPart().setFetch( nodeBuilder().value( fetch ), fetchClauseType );
+		return this;
+	}
+
+	@Override
+	public FetchClauseType getFetchClauseType() {
+		return getQueryPart().getFetchClauseType();
+	}
 }

hibernate-core/src/main/java/org/hibernate/sql/ast/tree/insert/Values.java

@@ -12,7 +12,7 @@
 import java.util.List;
 
 public class Values {
-	private List<Expression> expressions = new ArrayList<>();
+	private final List<Expression> expressions = new ArrayList<>();
 
 	public List<Expression> getExpressions() {
 		return expressions;

hibernate-core/src/main/java/org/hibernate/type/BasicTypeRegistry.java

@@ -32,10 +32,10 @@ public class BasicTypeRegistry implements Serializable {
 
 	private final TypeConfiguration typeConfiguration;
 
-	private final Map<SqlTypeDescriptor,Map<JavaTypeDescriptor<?>,BasicType<?>>> registryValues = new ConcurrentHashMap<>();
+	private final Map<SqlTypeDescriptor, Map<JavaTypeDescriptor<?>, BasicType<?>>> registryValues = new ConcurrentHashMap<>();
 	private boolean primed;
 
-	private Map<String, BasicType> typesByName = new ConcurrentHashMap<>();
+	private final Map<String, BasicType<?>> typesByName = new ConcurrentHashMap<>();
 
 	public BasicTypeRegistry(TypeConfiguration typeConfiguration){
 		this.typeConfiguration = typeConfiguration;
@@ -44,11 +44,12 @@ public BasicTypeRegistry(TypeConfiguration typeConfiguration){
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// Access
 
-	public BasicType getRegisteredType(String key) {
+	public <J> BasicType<J> getRegisteredType(String key) {
-		return typesByName.get( key );
+		//noinspection unchecked
+		return (BasicType<J>) typesByName.get( key );
 	}
 
-	public BasicType getRegisteredType(Class javaType) {
+	public <J> BasicType<J> getRegisteredType(Class<J> javaType) {
 		return getRegisteredType( javaType.getName() );
 	}
 
@@ -56,12 +57,12 @@ public BasicType getRegisteredType(Class javaType) {
 	 * Find an existing BasicType registration for the given JavaTypeDescriptor and
 	 * SqlTypeDescriptor combo or create (and register) one.
 	 */
-	public BasicType<?> resolve(JavaTypeDescriptor<?> jtdToUse, SqlTypeDescriptor stdToUse) {
+	public <J> BasicType<J> resolve(JavaTypeDescriptor<J> jtdToUse, SqlTypeDescriptor stdToUse) {
 		//noinspection unchecked
 		return resolve(
 				jtdToUse,
 				stdToUse,
-				() -> new StandardBasicTypeImpl( jtdToUse, stdToUse )
+				() -> new StandardBasicTypeImpl<>( jtdToUse, stdToUse )
 		);
 	}
 
@@ -69,28 +70,29 @@ public BasicType<?> resolve(JavaTypeDescriptor<?> jtdToUse, SqlTypeDescriptor st
 	 * Find an existing BasicType registration for the given JavaTypeDescriptor and
 	 * SqlTypeDescriptor combo or create (and register) one.
 	 */
-	public BasicType<?> resolve(JavaTypeDescriptor<?> jtdToUse, SqlTypeDescriptor stdToUse, Supplier<BasicType<?>> creator) {
+	public <J> BasicType<J> resolve(JavaTypeDescriptor<J> jtdToUse, SqlTypeDescriptor stdToUse, Supplier<BasicType<J>> creator) {
 		final Map<JavaTypeDescriptor<?>, BasicType<?>> typeByJtdForStd = registryValues.computeIfAbsent(
 				stdToUse,
 				sqlTypeDescriptor -> new ConcurrentHashMap<>()
 		);
 
-		return typeByJtdForStd.computeIfAbsent( jtdToUse, javaDescriptor -> creator.get() );
+		//noinspection unchecked
+		return (BasicType<J>) typeByJtdForStd.computeIfAbsent( jtdToUse, javaDescriptor -> creator.get() );
 	}
 
 
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// Mutations
 
-	public void register(BasicType type) {
+	public void register(BasicType<?> type) {
 		register( type, type.getRegistrationKeys() );
 	}
 
-	public void register(BasicType type, String key) {
+	public void register(BasicType<?> type, String key) {
 		typesByName.put( key, type );
 	}
 
-	public void register(BasicType type, String... keys) {
+	public void register(BasicType<?> type, String... keys) {
 		if ( ! isPrimed() ) {
 			throw new IllegalStateException( "BasicTypeRegistry not yet primed.  Calls to `#register` not valid until after primed" );
 		}
@@ -110,7 +112,7 @@ public void register(BasicType type, String... keys) {
 		}
 	}
 
-	private void applyOrOverwriteEntry(BasicType type) {
+	private void applyOrOverwriteEntry(BasicType<?> type) {
 		final Map<JavaTypeDescriptor<?>, BasicType<?>> mappingsForStdToUse = registryValues.computeIfAbsent(
 				type.getSqlTypeDescriptor(),
 				sqlTypeDescriptor -> new ConcurrentHashMap<>()
@@ -133,7 +135,7 @@ public void register(UserType type, String... keys) {
 
 	public void unregister(String... keys) {
 		for ( String key : keys ) {
-			final BasicType removed = typesByName.remove( key );
+			final BasicType<?> removed = typesByName.remove( key );
 
 
 		}
@@ -151,7 +153,7 @@ public void primed() {
 		this.primed = true;
 	}
 
-	public void addPrimeEntry(BasicType type, String legacyTypeClassName, String[] registrationKeys) {
+	public void addPrimeEntry(BasicType<?> type, String legacyTypeClassName, String[] registrationKeys) {
 		if ( primed ) {
 			throw new IllegalStateException( "BasicTypeRegistry already primed" );
 		}
@@ -176,7 +178,7 @@ public void addPrimeEntry(BasicType type, String legacyTypeClassName, String[] r
 		}
 	}
 
-	private void primeRegistryEntry(BasicType type) {
+	private void primeRegistryEntry(BasicType<?> type) {
 		final Map<JavaTypeDescriptor<?>, BasicType<?>> mappingsForStdToUse = registryValues.computeIfAbsent(
 				type.getSqlTypeDescriptor(),
 				sqlTypeDescriptor -> new ConcurrentHashMap<>()
@@ -197,7 +199,7 @@ private void primeRegistryEntry(BasicType type) {
 		}
 	}
 
-	private void applyRegistrationKeys(BasicType type, String[] keys) {
+	private void applyRegistrationKeys(BasicType<?> type, String[] keys) {
 		for ( String key : keys ) {
 			// be safe...
 			if ( key == null ) {

hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java

@@ -541,22 +541,22 @@ else if ( matchesJavaType( secondType, Short.class ) ) {
 		}
 	}
 
-	@SuppressWarnings("unchecked")
+	private static boolean matchesJavaType(SqmExpressable<?> type, Class<?> javaType) {
-	private static boolean matchesJavaType(SqmExpressable type, Class javaType) {
 		assert javaType != null;
 		return type != null && javaType.isAssignableFrom( type.getExpressableJavaTypeDescriptor().getJavaType() );
 	}
 
 
-	private final ConcurrentHashMap<Class,BasicType> basicTypeByJavaType = new ConcurrentHashMap<>();
+	private final ConcurrentHashMap<Class<?>, BasicType<?>> basicTypeByJavaType = new ConcurrentHashMap<>();
 
-	public BasicType getBasicTypeForJavaType(Class<?> javaType) {
+	public <J> BasicType<J> getBasicTypeForJavaType(Class<J> javaType) {
-		final BasicType existing = basicTypeByJavaType.get( javaType );
+		final BasicType<?> existing = basicTypeByJavaType.get( javaType );
 		if ( existing != null ) {
-			return existing;
+			//noinspection unchecked
+			return (BasicType<J>) existing;
 		}
 
-		final BasicType registeredType = getBasicTypeRegistry().getRegisteredType( javaType );
+		final BasicType<J> registeredType = getBasicTypeRegistry().getRegisteredType( javaType );
 		if ( registeredType != null ) {
 			basicTypeByJavaType.put( javaType, registeredType );
 			return registeredType;
@@ -565,7 +565,7 @@ public BasicType getBasicTypeForJavaType(Class<?> javaType) {
 		return null;
 	}
 
-	public BasicType standardBasicTypeForJavaType(Class<?> javaType) {
+	public <J> BasicType<J> standardBasicTypeForJavaType(Class<J> javaType) {
 		if ( javaType == null ) {
 			return null;
 		}
@@ -573,48 +573,49 @@ public BasicType standardBasicTypeForJavaType(Class<?> javaType) {
 		//noinspection unchecked
 		return standardBasicTypeForJavaType(
 				javaType,
-				javaTypeDescriptor -> new StandardBasicTypeImpl(
+				javaTypeDescriptor -> new StandardBasicTypeImpl<>(
 						javaTypeDescriptor,
 						javaTypeDescriptor.getJdbcRecommendedSqlType( getCurrentBaseSqlTypeIndicators() )
 				)
 		);
 	}
 
-	public BasicType standardBasicTypeForJavaType(
+	public <J> BasicType<J> standardBasicTypeForJavaType(
-			Class<?> javaType,
+			Class<J> javaType,
-			Function<JavaTypeDescriptor<?>,BasicType> creator) {
+			Function<JavaTypeDescriptor<J>, BasicType<J>> creator) {
 		if ( javaType == null ) {
 			return null;
 		}
-		return basicTypeByJavaType.computeIfAbsent(
+		//noinspection unchecked
+		return (BasicType<J>) basicTypeByJavaType.computeIfAbsent(
 				javaType,
 				jt -> {
 					// See if one exists in the BasicTypeRegistry and use that one if so
-					final BasicType registeredType = basicTypeRegistry.getRegisteredType( javaType );
+					final BasicType<J> registeredType = basicTypeRegistry.getRegisteredType( javaType );
 					if ( registeredType != null ) {
 						return registeredType;
 					}
 
 					// otherwise, apply the creator
-					final JavaTypeDescriptor javaTypeDescriptor = javaTypeDescriptorRegistry.resolveDescriptor( javaType );
+					final JavaTypeDescriptor<J> javaTypeDescriptor = javaTypeDescriptorRegistry.resolveDescriptor( javaType );
 					return creator.apply( javaTypeDescriptor );
 				}
 		);
 	}
 
-	public TemporalType getSqlTemporalType(SqmExpressable type) {
+	public TemporalType getSqlTemporalType(SqmExpressable<?> type) {
 		if ( type == null ) {
 			return null;
 		}
 		return getSqlTemporalType( type.getExpressableJavaTypeDescriptor().getJdbcRecommendedSqlType( getCurrentBaseSqlTypeIndicators() ) );
 	}
 
-	public static TemporalType getSqlTemporalType(MappingModelExpressable type) {
+	public static TemporalType getSqlTemporalType(MappingModelExpressable<?> type) {
 		if ( type instanceof BasicValuedMapping ) {
 			return getSqlTemporalType( ( (BasicValuedMapping) type ).getJdbcMapping().getSqlTypeDescriptor() );
 		}
 		else if (type instanceof SingleColumnType) {
-			return getSqlTemporalType( ((SingleColumnType) type).sqlType() );
+			return getSqlTemporalType( ((SingleColumnType<?>) type).sqlType() );
 		}
 		return null;
 	}

hibernate-core/src/test/java/org/hibernate/orm/test/entitygraph/ast/CriteriaEntityGraphTest.java

@@ -369,12 +369,12 @@ private <T> SelectStatement buildSqlSelectAst(
 		final HqlQueryImplementor<String> hqlQuery = (HqlQueryImplementor<String>) query;
 		hqlQuery.applyGraph( entityGraph, mode );
 
-		final SqmSelectStatement sqmStatement = (SqmSelectStatement) hqlQuery.getSqmStatement();
+		final SqmSelectStatement<String> sqmStatement = (SqmSelectStatement<String>) hqlQuery.getSqmStatement();
 
 		final StandardSqmTranslator<SelectStatement> sqmConverter = new StandardSqmTranslator<>(
 				sqmStatement,
 				hqlQuery.getQueryOptions(),
-				( (QuerySqmImpl) hqlQuery ).getDomainParameterXref(),
+				( (QuerySqmImpl<?>) hqlQuery ).getDomainParameterXref(),
 				query.getParameterBindings(),
 				loadQueryInfluencers,
 				session.getSessionFactory()

hibernate-core/src/test/java/org/hibernate/orm/test/entitygraph/ast/HqlEntityGraphTest.java

@@ -365,12 +365,12 @@ private <T> SelectStatement buildSqlSelectAst(
 		final HqlQueryImplementor<String> hqlQuery = (HqlQueryImplementor<String>) query;
 		hqlQuery.applyGraph( entityGraph, mode );
 
-		final SqmSelectStatement sqmStatement = (SqmSelectStatement) hqlQuery.getSqmStatement();
+		final SqmSelectStatement<String> sqmStatement = (SqmSelectStatement<String>) hqlQuery.getSqmStatement();
 
 		final StandardSqmTranslator<SelectStatement> sqmConverter = new StandardSqmTranslator<>(
 				sqmStatement,
 				hqlQuery.getQueryOptions(),
-				( (QuerySqmImpl) hqlQuery ).getDomainParameterXref(),
+				( (QuerySqmImpl<?>) hqlQuery ).getDomainParameterXref(),
 				query.getParameterBindings(),
 				loadQueryInfluencers,
 				session.getSessionFactory()

hibernate-core/src/test/java/org/hibernate/orm/test/intg/sqm/HqlTranslationNoFactoryTests.java

@@ -56,7 +56,7 @@ public void testHqlTranslationNoSessionFactory(DomainModelScope modelScope, Serv
 		final String hql = "select a from SalesAssociate a";
 
 		final HqlTranslator hqlTranslator = buildHqlTranslator( modelScope, registryScope );
-		final SqmStatement sqmStatement = hqlTranslator.translate( hql );
+		final SqmStatement<?> sqmStatement = hqlTranslator.translate( hql );
 		assert sqmStatement != null;
 	}
 

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/AliasCollisionTest.java

@@ -89,9 +89,9 @@ public void testDuplicateIdentificationVariableCollision() {
 	@Test
 	public void testSameIdentificationVariablesInSubquery() {
 		final String query = "select a from SimpleEntity a where a.someString in (select a.someString from SimpleEntity a where a.someInteger = 5)";
-		final SqmSelectStatement sqm = interpretSelect( query );
+		final SqmSelectStatement<?> sqm = interpretSelect( query );
 
-		final SqmQuerySpec querySpec = sqm.getQuerySpec();
+		final SqmQuerySpec<?> querySpec = sqm.getQuerySpec();
 
 		final List<SqmSelection> selections = querySpec.getSelectClause().getSelections();
 		assertThat( selections, hasSize( 1 ) );
@@ -118,9 +118,9 @@ public void testSameIdentificationVariablesInSubquery() {
 	public void testSubqueryUsingIdentificationVariableDefinedInRootQuery() {
 		final String query = "select a from SimpleEntity a where a.someString in " +
 				"( select b.someString from SimpleEntity b where a.someLong = b.someLong )";
-		final SqmSelectStatement sqm = interpretSelect( query );
+		final SqmSelectStatement<?> sqm = interpretSelect( query );
 
-		final SqmQuerySpec querySpec = sqm.getQuerySpec();
+		final SqmQuerySpec<?> querySpec = sqm.getQuerySpec();
 
 		final List<SqmSelection> selections = querySpec.getSelectClause().getSelections();
 		assertThat( selections, hasSize( 1 ) );

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/AttributePathTests.java

@@ -47,7 +47,7 @@ protected Class[] getAnnotatedClasses() {
 
 	@Test
 	public void testImplicitJoinReuse() {
-		final SqmSelectStatement statement = interpretSelect( "select s.mate.dob, s.mate.numberOfToes from Person s" );
+		final SqmSelectStatement<?> statement = interpretSelect( "select s.mate.dob, s.mate.numberOfToes from Person s" );
 
 		assertThat( statement.getQuerySpec().getFromClause().getRoots().size(), is(1) );
 		final SqmRoot<?> sqmRoot = statement.getQuerySpec().getFromClause().getRoots().get( 0 );
@@ -75,7 +75,7 @@ private void assertPropertyPath(SqmExpression expression, String expectedFullPat
 
 	@Test
 	public void testImplicitJoinReuse2() {
-		final SqmSelectStatement statement = interpretSelect( "select s.mate from Person s where s.mate.dob = ?1" );
+		final SqmSelectStatement<?> statement = interpretSelect( "select s.mate from Person s where s.mate.dob = ?1" );
 
 		assertThat( statement.getQuerySpec().getFromClause().getRoots().size(), is(1) );
 		final SqmRoot<?> sqmRoot = statement.getQuerySpec().getFromClause().getRoots().get( 0 );
@@ -114,20 +114,20 @@ public void testEntityIdReferences() {
 				.entity( OddOne.class );
 		final SingularPersistentAttribute<OddOne, ?> idAttribute = entity.findIdAttribute();
 
-		final SqmSelectStatement sqmSelectStatement = interpretSelect( "select s.id from OddOne s where s.pk = ?1" );
+		final SqmSelectStatement<?> sqmSelectStatement = interpretSelect( "select s.id from OddOne s where s.pk = ?1" );
 
-		final SqmQuerySpec querySpec = sqmSelectStatement.getQuerySpec();
+		final SqmQuerySpec<?> querySpec = sqmSelectStatement.getQuerySpec();
 		assertThat( querySpec.getSelectClause().getSelections().size(), is(1) );
-		final SqmSelection sqmSelection = querySpec.getSelectClause().getSelections().get( 0 );
+		final SqmSelection<?> sqmSelection = querySpec.getSelectClause().getSelections().get( 0 );
 		assertThat( sqmSelection.getSelectableNode(), not( sameInstance( idAttribute ) ) );
 
 		final SqmExpression<?> pkRef = ( (SqmComparisonPredicate) querySpec.getRestriction() ).getLeftHandExpression();
-		assertThat( ( (SqmPath) pkRef ).getJavaType(), sameInstance( String.class ) );
+		assertThat( ( (SqmPath<?>) pkRef ).getJavaType(), sameInstance( String.class ) );
 	}
 
 	@Test
 	public void testCanonicalReferences() {
-		final SqmSelectStatement sqm = interpretSelect( "select s.mate from Person s where id(s) = ?1" );
+		final SqmSelectStatement<?> sqm = interpretSelect( "select s.mate from Person s where id(s) = ?1" );
 		assertThat( sqm.getQuerySpec().getRestriction(), notNullValue() );
 		final SqmComparisonPredicate restriction = (SqmComparisonPredicate) sqm.getQuerySpec().getRestriction();
 		assertThat( restriction, notNullValue() );
@@ -135,11 +135,11 @@ public void testCanonicalReferences() {
 
 	@Test
 	public void testManyToOneReference() {
-		final SqmSelectStatement sqm = interpretSelect( "select s.mate from Person s" );
+		final SqmSelectStatement<?> sqm = interpretSelect( "select s.mate from Person s" );
 		final List<SqmSelection> selections = sqm.getQuerySpec().getSelectClause().getSelections();
 		assertThat( selections.size(), is( 1 ) );
-		final SqmSelection selection = selections.get( 0 );
+		final SqmSelection<?> selection = selections.get( 0 );
-		final SqmSelectableNode selectableNode = selection.getSelectableNode();
+		final SqmSelectableNode<?> selectableNode = selection.getSelectableNode();
 		assert Person.class.equals( selectableNode.getJavaTypeDescriptor().getJavaType() );
 	}
 

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/CaseExpressionsTest.java

@@ -40,7 +40,7 @@ protected Class[] getAnnotatedClasses() {
 
 	@Test
 	public void testBasicSimpleCaseExpression() {
-		SqmSelectStatement select = interpretSelect(
+		SqmSelectStatement<?> select = interpretSelect(
 				"select p from Person p where p.numberOfToes = case p.dob when ?1 then 6 else 8 end"
 		);
 
@@ -65,7 +65,7 @@ public void testBasicSimpleCaseExpression() {
 
 	@Test
 	public void testBasicSearchedCaseExpression() {
-		SqmSelectStatement select = interpretSelect(
+		SqmSelectStatement<?> select = interpretSelect(
 				"select p from Person p where p.numberOfToes = case when p.dob = ?1 then 6 else 8 end"
 		);
 
@@ -87,7 +87,7 @@ public void testBasicSearchedCaseExpression() {
 
 	@Test
 	public void testBasicCoalesceExpression() {
-		SqmSelectStatement select = interpretSelect(
+		SqmSelectStatement<?> select = interpretSelect(
 				"select coalesce(p.nickName, p.mate.nickName) from Person p"
 		);
 
@@ -104,7 +104,7 @@ public void testBasicCoalesceExpression() {
 
 	@Test
 	public void testBasicNullifExpression() {
-		SqmSelectStatement select = interpretSelect(
+		SqmSelectStatement<?> select = interpretSelect(
 				"select nullif(p.nickName, p.mate.nickName) from Person p"
 		);
 

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/DynamicInstantiationTests.java

@@ -45,7 +45,7 @@ protected Class[] getAnnotatedClasses() {
 
 	@Test
 	public void testSimpleDynamicInstantiationSelection() {
-		SqmSelectStatement statement = interpretSelect(
+		SqmSelectStatement<?> statement = interpretSelect(
 				"select new org.hibernate.orm.test.query.sqm.domain.ConstructedLookupListItem( e.id, e.theString ) from EntityOfBasics e"
 		);
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
@@ -62,7 +62,7 @@ public void testSimpleDynamicInstantiationSelection() {
 
 	@Test
 	public void testMultipleDynamicInstantiationSelection() {
-		SqmSelectStatement statement = interpretSelect(
+		SqmSelectStatement<?> statement = interpretSelect(
 				"select new org.hibernate.orm.test.query.sqm.domain.ConstructedLookupListItem( e.id, e.theString ), " +
 						"new org.hibernate.orm.test.query.sqm.domain.ConstructedLookupListItem( e.id, e.theString ) " +
 						"from EntityOfBasics e"
@@ -99,7 +99,7 @@ public void testMultipleDynamicInstantiationSelection() {
 
 	@Test
 	public void testMixedAttributeAndDynamicInstantiationSelection() {
-		SqmSelectStatement statement = interpretSelect(
+		SqmSelectStatement<?> statement = interpretSelect(
 				"select new org.hibernate.orm.test.query.sqm.domain.ConstructedLookupListItem( e.id, e.theString ), e.theInteger from EntityOfBasics e"
 		);
 		assertEquals( 2, statement.getQuerySpec().getSelectClause().getSelections().size() );
@@ -117,7 +117,7 @@ public void testMixedAttributeAndDynamicInstantiationSelection() {
 		assertThat( instantiation.getArguments(), hasSize( 2 ) );
 
 
-		final SqmPath theIntegerPath = TestingUtil.cast(
+		final SqmPath<?> theIntegerPath = TestingUtil.cast(
 				statement.getQuerySpec().getSelectClause().getSelections().get( 1 ).getSelectableNode(),
 				SqmPath.class
 		);
@@ -127,7 +127,7 @@ public void testMixedAttributeAndDynamicInstantiationSelection() {
 
 	@Test
 	public void testNestedDynamicInstantiationSelection() {
-		SqmSelectStatement statement = interpretSelect(
+		SqmSelectStatement<?> statement = interpretSelect(
 				"select new org.hibernate.orm.test.query.sqm.domain.NestedCtorLookupListItem(" +
 						" e.id, " +
 						" e.theString, " +
@@ -154,7 +154,7 @@ public void testNestedDynamicInstantiationSelection() {
 		);
 		assertThat( firstArg.getReferencedPathSource().getPathName(), is( "id" ) );
 
-		final SqmPath secondArg = TestingUtil.cast(
+		final SqmPath<?> secondArg = TestingUtil.cast(
 				instantiation.getArguments().get( 1 ).getSelectableNode(),
 				SqmPath.class
 		);
@@ -175,7 +175,7 @@ public void testNestedDynamicInstantiationSelection() {
 
 	@Test
 	public void testSimpleDynamicListInstantiation() {
-		SqmSelectStatement statement = interpretSelect( "select new list( e.id, e.theString ) from EntityOfBasics e" );
+		SqmSelectStatement<?> statement = interpretSelect( "select new list( e.id, e.theString ) from EntityOfBasics e" );
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
 
 		final SqmDynamicInstantiation<?> instantiation = TestingUtil.cast(
@@ -208,7 +208,7 @@ public void testSimpleDynamicListInstantiation() {
 
 	@Test
 	public void testSimpleDynamicMapInstantiation() {
-		SqmSelectStatement statement = interpretSelect( "select new map( e.id as id, e.theString as ts ) from EntityOfBasics e" );
+		SqmSelectStatement<?> statement = interpretSelect( "select new map( e.id as id, e.theString as ts ) from EntityOfBasics e" );
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
 
 		final SqmDynamicInstantiation<?> instantiation = TestingUtil.cast(
@@ -245,7 +245,7 @@ public void testSimpleInjectedInstantiation() {
 		// todo (6.0) : this should blow up as early as possible - no aliases for bean-injection-based dynamic-instantiation
 		//		atm this does not fail until later when building the SQL AST
 
-		SqmSelectStatement statement = interpretSelect(
+		SqmSelectStatement<?> statement = interpretSelect(
 				"select new org.hibernate.orm.test.query.sqm.domain.InjectedLookupListItem( e.id, e.theString ) from EntityOfBasics e"
 		);
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/FromClauseTests.java

@@ -47,7 +47,7 @@ protected Class[] getAnnotatedClasses() {
 
 	@Test
 	public void testSimpleFrom() {
-		final SqmSelectStatement selectStatement = interpretSelect( "select p.nickName from Person p" );
+		final SqmSelectStatement<?> selectStatement = interpretSelect( "select p.nickName from Person p" );
 
 		final SqmFromClause fromClause = selectStatement.getQuerySpec().getFromClause();
 		assertThat( fromClause, notNullValue() );
@@ -61,7 +61,7 @@ public void testSimpleFrom() {
 
 	@Test
 	public void testMultipleSpaces() {
-		final SqmSelectStatement selectStatement = interpretSelect(
+		final SqmSelectStatement<?> selectStatement = interpretSelect(
 				"select p.nickName from Person p, Person p2"
 		);
 
@@ -85,7 +85,7 @@ public void testMultipleSpaces() {
 
 	@Test
 	public void testImplicitAlias() {
-		final SqmSelectStatement selectStatement = interpretSelect( "select nickName from Person" );
+		final SqmSelectStatement<?> selectStatement = interpretSelect( "select nickName from Person" );
 
 		final SqmFromClause fromClause = selectStatement.getQuerySpec().getFromClause();
 		assertThat( fromClause, notNullValue() );
@@ -99,7 +99,7 @@ public void testImplicitAlias() {
 
 	@Test
 	public void testCrossJoin() {
-		final SqmSelectStatement selectStatement = interpretSelect(
+		final SqmSelectStatement<?> selectStatement = interpretSelect(
 				"select p.nickName from Person p cross join Person p2"
 		);
 
@@ -125,7 +125,7 @@ public void testSimpleImplicitInnerJoin() {
 	}
 
 	private void simpleJoinAssertions(
-			SqmSelectStatement selectStatement,
+			SqmSelectStatement<?> selectStatement,
 			SqmJoinType joinType,
 			String rootAlias,
 			String joinAlias) {
@@ -174,7 +174,7 @@ public void testSimpleExplicitLeftOuterJoin() {
 
 	@Test
 	public void testAttributeJoinWithOnClause() {
-		final SqmSelectStatement selectStatement = interpretSelect(
+		final SqmSelectStatement<?> selectStatement = interpretSelect(
 				"select a from Person a left outer join a.mate c on c.numberOfToes > 5 and c.numberOfToes < 20 "
 		);
 
@@ -199,7 +199,7 @@ public void testAttributeJoinWithOnClause() {
 	@Test
 	public void testPathExpression() {
 		final String query = "select p.mate from Person p";
-		SqmSelectStatement selectStatement = interpretSelect( query );
+		SqmSelectStatement<?> selectStatement = interpretSelect( query );
 
 
 		final SqmFromClause fromClause = selectStatement.getQuerySpec().getFromClause();
@@ -215,7 +215,7 @@ public void testPathExpression() {
 	@Test
 	public void testFromElementReferenceInSelect() {
 		final String query = "select p from Person p";
-		SqmSelectStatement selectStatement = interpretSelect( query );
+		SqmSelectStatement<?> selectStatement = interpretSelect( query );
 
 		final SqmFromClause fromClause = selectStatement.getQuerySpec().getFromClause();
 		assertThat( fromClause, notNullValue() );
@@ -225,7 +225,7 @@ public void testFromElementReferenceInSelect() {
 		assertThat( sqmRoot, notNullValue() );
 
 		assertThat( selectStatement.getQuerySpec().getSelectClause().getSelections(), hasSize( 1 ) );
-		final SqmSelection sqmSelection = selectStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
+		final SqmSelection<?> sqmSelection = selectStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
 
 		assertThat( sqmSelection.getSelectableNode(), instanceOf( SqmRoot.class ) );
 	}
@@ -233,7 +233,7 @@ public void testFromElementReferenceInSelect() {
 	@Test
 	public void testFromElementReferenceInOrderBy() {
 		final String query = "select p from Person p order by p";
-		SqmSelectStatement selectStatement = interpretSelect( query );
+		SqmSelectStatement<?> selectStatement = interpretSelect( query );
 
 		final SqmFromClause fromClause = selectStatement.getQuerySpec().getFromClause();
 		assertThat( fromClause, notNullValue() );

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/MutationTests.java

@@ -33,7 +33,7 @@
 public class MutationTests {
 	@Test
 	public void testSimpleDeleteTranslation(SessionFactoryScope scope) {
-		final SqmDeleteStatement sqmDelete = (SqmDeleteStatement) scope.getSessionFactory()
+		final SqmDeleteStatement<?> sqmDelete = (SqmDeleteStatement<?>) scope.getSessionFactory()
 				.getQueryEngine()
 				.getHqlTranslator()
 				.translate( "delete BasicEntity" );
@@ -45,7 +45,7 @@ public void testSimpleDeleteTranslation(SessionFactoryScope scope) {
 
 	@Test
 	public void testSimpleRestrictedDeleteTranslation(SessionFactoryScope scope) {
-		final SqmDeleteStatement sqmDelete = (SqmDeleteStatement) scope.getSessionFactory()
+		final SqmDeleteStatement<?> sqmDelete = (SqmDeleteStatement<?>) scope.getSessionFactory()
 				.getQueryEngine()
 				.getHqlTranslator()
 				.translate( "delete BasicEntity where data = 'abc'" );

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/ParameterTests.java

@@ -82,7 +82,7 @@ public void testParameterCollection() {
 	@Test
 	public void testAllowMultiValuedBinding() {
 		final SqmSelectStatement<?> sqm = interpretSelect( "select a.nickName from Person a where a.numberOfToes in (?1)" );
-		final SqmParameter parameter = sqm.getSqmParameters().iterator().next();
+		final SqmParameter<?> parameter = sqm.getSqmParameters().iterator().next();
 
 		assertThat( parameter.allowMultiValuedBinding(), is(true) );
 	}

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/SelectClauseTests.java

@@ -54,23 +54,23 @@ public class SelectClauseTests extends BaseSqmUnitTest {
 
 	@Test
 	public void testSimpleAliasSelection() {
-		SqmSelectStatement statement = interpretSelect( "select p from Person p" );
+		SqmSelectStatement<?> statement = interpretSelect( "select p from Person p" );
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
-		SqmSelection selection = statement.getQuerySpec().getSelectClause().getSelections().get( 0 );
+		SqmSelection<?> selection = statement.getQuerySpec().getSelectClause().getSelections().get( 0 );
 		assertThat( selection.getSelectableNode(), instanceOf( SqmRoot.class ) );
 	}
 
 	@Test
 	public void testSimpleAttributeSelection() {
-		SqmSelectStatement statement = interpretSelect( "select p.nickName from Person p" );
+		SqmSelectStatement<?> statement = interpretSelect( "select p.nickName from Person p" );
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
-		SqmSelection selection = statement.getQuerySpec().getSelectClause().getSelections().get( 0 );
+		SqmSelection<?> selection = statement.getQuerySpec().getSelectClause().getSelections().get( 0 );
 		assertThat( selection.getSelectableNode(), instanceOf( SqmSimplePath.class ) );
 	}
 
 	@Test
 	public void testCompoundAttributeSelection() {
-		SqmSelectStatement statement = interpretSelect( "select p.nickName, p.name.firstName from Person p" );
+		SqmSelectStatement<?> statement = interpretSelect( "select p.nickName, p.name.firstName from Person p" );
 		assertEquals( 2, statement.getQuerySpec().getSelectClause().getSelections().size() );
 		assertThat(
 				statement.getQuerySpec().getSelectClause().getSelections().get( 0 ).getSelectableNode(),
@@ -84,7 +84,7 @@ public void testCompoundAttributeSelection() {
 
 	@Test
 	public void testMixedAliasAndAttributeSelection() {
-		SqmSelectStatement statement = interpretSelect( "select p, p.nickName from Person p" );
+		SqmSelectStatement<?> statement = interpretSelect( "select p, p.nickName from Person p" );
 		assertEquals( 2, statement.getQuerySpec().getSelectClause().getSelections().size() );
 		assertThat(
 				statement.getQuerySpec().getSelectClause().getSelections().get( 0 ).getSelectableNode(),
@@ -99,10 +99,10 @@ public void testMixedAliasAndAttributeSelection() {
 	@Test
 	public void testBinaryArithmeticExpression() {
 		final String query = "select p.numberOfToes + p.numberOfToes as b from Person p";
-		final SqmSelectStatement selectStatement = interpretSelect( query );
+		final SqmSelectStatement<?> selectStatement = interpretSelect( query );
 
-		final SqmQuerySpec querySpec = selectStatement.getQuerySpec();
+		final SqmQuerySpec<?> querySpec = selectStatement.getQuerySpec();
-		final SqmSelection selection = querySpec.getSelectClause().getSelections().get( 0 );
+		final SqmSelection<?> selection = querySpec.getSelectClause().getSelections().get( 0 );
 
 		assertThat( querySpec.getFromClause().getRoots().size(), is(1) );
 		final SqmRoot<?> root = querySpec.getFromClause().getRoots().get( 0 );
@@ -110,12 +110,12 @@ public void testBinaryArithmeticExpression() {
 		assertThat( root.getJoins().size(), is(0) );
 
 		SqmBinaryArithmetic expression = (SqmBinaryArithmetic) selection.getSelectableNode();
-		SqmPath leftHandOperand = (SqmPath) expression.getLeftHandOperand();
+		SqmPath<?> leftHandOperand = (SqmPath<?>) expression.getLeftHandOperand();
 		assertThat( leftHandOperand.getLhs(), sameInstance( root ) );
 		assertThat( leftHandOperand.getReferencedPathSource().getPathName(), is( "numberOfToes" ) );
 //		assertThat( leftHandOperand.getFromElement(), nullValue() );
 
-		SqmPath rightHandOperand = (SqmPath) expression.getRightHandOperand();
+		SqmPath<?> rightHandOperand = (SqmPath<?>) expression.getRightHandOperand();
 		assertThat( rightHandOperand.getLhs(), sameInstance( root ) );
 		assertThat( rightHandOperand.getReferencedPathSource().getPathName(), is( "numberOfToes" ) );
 //		assertThat( leftHandOperand.getFromElement(), nullValue() );
@@ -124,10 +124,10 @@ public void testBinaryArithmeticExpression() {
 	@Test
 	public void testBinaryArithmeticExpressionWithMultipleFromSpaces() {
 		final String query = "select p.numberOfToes + p2.numberOfToes as b from Person p, Person p2";
-		final SqmSelectStatement selectStatement = interpretSelect( query );
+		final SqmSelectStatement<?> selectStatement = interpretSelect( query );
 
-		final SqmQuerySpec querySpec = selectStatement.getQuerySpec();
+		final SqmQuerySpec<?> querySpec = selectStatement.getQuerySpec();
-		final SqmSelection selection = querySpec.getSelectClause().getSelections().get( 0 );
+		final SqmSelection<?> selection = querySpec.getSelectClause().getSelections().get( 0 );
 
 		assertThat( querySpec.getFromClause().getRoots().size(), is(2) );
 
@@ -139,11 +139,11 @@ public void testBinaryArithmeticExpressionWithMultipleFromSpaces() {
 
 		SqmBinaryArithmetic addExpression = (SqmBinaryArithmetic) selection.getSelectableNode();
 
-		SqmPath leftHandOperand = (SqmPath) addExpression.getLeftHandOperand();
+		SqmPath<?> leftHandOperand = (SqmPath<?>) addExpression.getLeftHandOperand();
 		assertThat( leftHandOperand.getLhs(), sameInstance( entityRoot ) );
 		assertThat( leftHandOperand.getReferencedPathSource().getPathName(), is( "numberOfToes" ) );
 
-		SqmPath rightHandOperand = (SqmPath) addExpression.getRightHandOperand();
+		SqmPath<?> rightHandOperand = (SqmPath<?>) addExpression.getRightHandOperand();
 		assertThat( rightHandOperand.getLhs(), sameInstance( entity2Root ) );
 		assertThat( rightHandOperand.getReferencedPathSource().getPathName(), is( "numberOfToes" ) );
 	}
@@ -165,20 +165,20 @@ public void testMapKeyFunction() {
 	}
 
 	private void collectionIndexFunctionAssertions(
-			SqmSelectStatement statement,
+			SqmSelectStatement<?> statement,
 			CollectionClassification expectedCollectionClassification,
 			Class<? extends SimpleDomainType> expectedIndexDomainTypeType,
 			String expectedAlias) {
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
 
-		final SqmSelectableNode selectedExpr = statement.getQuerySpec()
+		final SqmSelectableNode<?> selectedExpr = statement.getQuerySpec()
 				.getSelectClause()
 				.getSelections()
 				.get( 0 )
 				.getSelectableNode();
 
 		assertThat( selectedExpr, instanceOf( SqmSimplePath.class ) );
-		final SqmSimplePath selectedPath = (SqmSimplePath) selectedExpr;
+		final SqmSimplePath<?> selectedPath = (SqmSimplePath<?>) selectedExpr;
 
 		assertThat( selectedPath.getLhs().getExplicitAlias(), is( expectedAlias ) );
 
@@ -257,20 +257,20 @@ public void testCollectionValueFunction() {
 	}
 
 	private void collectionValueFunctionAssertions(
-			SqmSelectStatement statement,
+			SqmSelectStatement<?> statement,
 			String collectionRole,
 			String collectionIdentificationVariable) {
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
 
-		final SqmSelectableNode selectedExpression = statement.getQuerySpec()
+		final SqmSelectableNode<?> selectedExpression = statement.getQuerySpec()
 				.getSelectClause()
 				.getSelections()
 				.get( 0 )
 				.getSelectableNode();
 
 		assertThat( selectedExpression, instanceOf( SqmPath.class ) );
-		final SqmPath selectedPath = (SqmPath) selectedExpression;
+		final SqmPath<?> selectedPath = (SqmPath<?>) selectedExpression;
-		final SqmPathSource referencedPathSource = selectedPath.getReferencedPathSource();
+		final SqmPathSource<?> referencedPathSource = selectedPath.getReferencedPathSource();
 
 		final String ownerName = StringHelper.qualifier( collectionRole );
 		final String attributeName = StringHelper.unqualify( collectionRole );
@@ -289,7 +289,7 @@ public void testMapEntryFunction() {
 		testMapEntryFunctionAssertions( interpretSelect( "select entry(m) from EntityOfMaps e join e.sortedManyToManyByBasic m" ) );
 	}
 
-	private void testMapEntryFunctionAssertions(SqmSelectStatement statement) {
+	private void testMapEntryFunctionAssertions(SqmSelectStatement<?> statement) {
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
 
 		final SqmMapEntryReference mapEntryPath = (SqmMapEntryReference) statement.getQuerySpec()
@@ -300,16 +300,16 @@ private void testMapEntryFunctionAssertions(SqmSelectStatement statement) {
 
 		assertThat( mapEntryPath.getJavaTypeDescriptor().getJavaType(), is( equalTo( Map.Entry.class ) ) );
 
-		final SqmPath selectedPathLhs = mapEntryPath.getMapPath();
+		final SqmPath<?> selectedPathLhs = mapEntryPath.getMapPath();
 		assertThat( selectedPathLhs.getExplicitAlias(), is( "m" ) );
 	}
 
 	@Test
 	public void testSimpleRootEntitySelection() {
-		SqmSelectStatement statement = interpretSelect( "select e from EntityOfBasics e" );
+		SqmSelectStatement<?> statement = interpretSelect( "select e from EntityOfBasics e" );
 
 		assertEquals( 1, statement.getQuerySpec().getSelectClause().getSelections().size() );
-		final SqmPath sqmEntityReference = TestingUtil.cast(
+		final SqmPath<?> sqmEntityReference = TestingUtil.cast(
 				statement.getQuerySpec().getSelectClause().getSelections().get( 0 ).getSelectableNode(),
 				SqmPath.class
 		);

hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/WhereClauseTests.java

@@ -49,7 +49,7 @@ protected Class[] getAnnotatedClasses() {
 
 	@Test
 	public void testIsNotNullPredicate() {
-		SqmSelectStatement statement = interpretSelect( "select l from Person l where l.nickName is not null" );
+		SqmSelectStatement<?> statement = interpretSelect( "select l from Person l where l.nickName is not null" );
 		assertThat( statement.getQuerySpec().getWhereClause().getPredicate(), instanceOf( SqmNullnessPredicate.class ) );
 		SqmNullnessPredicate predicate = (SqmNullnessPredicate) statement.getQuerySpec().getWhereClause().getPredicate();
 		assertThat( predicate.isNegated(), is(true) );
@@ -57,7 +57,7 @@ public void testIsNotNullPredicate() {
 
 	@Test
 	public void testNotIsNullPredicate() {
-		SqmSelectStatement statement = interpretSelect( "select l from Person l where not l.nickName is null" );
+		SqmSelectStatement<?> statement = interpretSelect( "select l from Person l where not l.nickName is null" );
 		assertThat( statement.getQuerySpec().getWhereClause().getPredicate(), instanceOf( SqmNullnessPredicate.class ) );
 		SqmNullnessPredicate predicate = (SqmNullnessPredicate) statement.getQuerySpec().getWhereClause().getPredicate();
 		assertThat( predicate.isNegated(), is(true) );
@@ -65,7 +65,7 @@ public void testNotIsNullPredicate() {
 
 	@Test
 	public void testNotIsNotNullPredicate() {
-		SqmSelectStatement statement = interpretSelect( "select l from Person l where not l.nickName is not null" );
+		SqmSelectStatement<?> statement = interpretSelect( "select l from Person l where not l.nickName is not null" );
 		assertThat( statement.getQuerySpec().getWhereClause().getPredicate(), instanceOf( SqmNullnessPredicate.class ) );
 		SqmNullnessPredicate predicate = (SqmNullnessPredicate) statement.getQuerySpec().getWhereClause().getPredicate();
 		assertThat( predicate.isNegated(), is(false) );
@@ -73,7 +73,7 @@ public void testNotIsNotNullPredicate() {
 
 	@Test
 	public void testCollectionSizeFunction() {
-		SqmSelectStatement statement = interpretSelect( "SELECT t FROM EntityOfSets t WHERE SIZE( t.setOfBasics ) = 311" );
+		SqmSelectStatement<?> statement = interpretSelect( "SELECT t FROM EntityOfSets t WHERE SIZE( t.setOfBasics ) = 311" );
 
 		SqmPredicate predicate = statement.getQuerySpec().getWhereClause().getPredicate();
 		assertThat( predicate, instanceOf( SqmComparisonPredicate.class ) );
@@ -82,7 +82,7 @@ public void testCollectionSizeFunction() {
 		assertThat( relationalPredicate.getSqmOperator(), is( ComparisonOperator.EQUAL ) );
 
 		assertThat( relationalPredicate.getRightHandExpression(), instanceOf( SqmLiteral.class ) );
-		assertThat( ( (SqmLiteral) relationalPredicate.getRightHandExpression() ).getLiteralValue(), is( 311 ) );
+		assertThat( ( (SqmLiteral<?>) relationalPredicate.getRightHandExpression() ).getLiteralValue(), is( 311 ) );
 
 		assertThat( relationalPredicate.getLeftHandExpression(), instanceOf( SqmCollectionSize.class ) );
 
@@ -93,7 +93,7 @@ public void testCollectionSizeFunction() {
 
 	@Test
 	public void testListIndexFunction() {
-		SqmSelectStatement statement = interpretSelect( "select l from EntityOfLists t join t.listOfBasics l where index(l) > 2" );
+		SqmSelectStatement<?> statement = interpretSelect( "select l from EntityOfLists t join t.listOfBasics l where index(l) > 2" );
 
 		SqmPredicate predicate = statement.getQuerySpec().getWhereClause().getPredicate();
 		assertThat( predicate, instanceOf( SqmComparisonPredicate.class ) );
@@ -102,10 +102,10 @@ public void testListIndexFunction() {
 		assertThat( relationalPredicate.getSqmOperator(), is( ComparisonOperator.GREATER_THAN ) );
 
 		assertThat( relationalPredicate.getRightHandExpression(), instanceOf( SqmLiteral.class ) );
-		assertThat( ( (SqmLiteral) relationalPredicate.getRightHandExpression() ).getLiteralValue(), is( 2 ) );
+		assertThat( ( (SqmLiteral<?>) relationalPredicate.getRightHandExpression() ).getLiteralValue(), is( 2 ) );
 
 		assertThat( relationalPredicate.getLeftHandExpression(), instanceOf( SqmPath.class ) );
-		final SqmPath indexPath = (SqmPath) relationalPredicate.getLeftHandExpression();
+		final SqmPath<?> indexPath = (SqmPath<?>) relationalPredicate.getLeftHandExpression();
 
 		assertThat( indexPath.getLhs(), notNullValue() );
 		assertThat( indexPath.getLhs().getExplicitAlias(), is( "l" ) );

hibernate-core/src/test/java/org/hibernate/orm/test/query/sqm/BaseSqmUnitTest.java

@@ -48,12 +48,12 @@ protected boolean strictJpaCompliance() {
 	public void registerAfterLoadAction(AfterLoadAction afterLoadAction) {
 	}
 
-	protected SqmSelectStatement interpretSelect(String hql) {
+	protected SqmSelectStatement<?> interpretSelect(String hql) {
 		return interpretSelect( hql, sessionFactory() );
 	}
 
-	public static SqmSelectStatement interpretSelect(String hql, SessionFactoryImplementor sessionFactory) {
+	public static SqmSelectStatement<?> interpretSelect(String hql, SessionFactoryImplementor sessionFactory) {
-		return (SqmSelectStatement) sessionFactory.getQueryEngine().getHqlTranslator().translate( hql );
+		return (SqmSelectStatement<?>) sessionFactory.getQueryEngine().getHqlTranslator().translate( hql );
 	}
 
 	@Override

hibernate-core/src/test/java/org/hibernate/orm/test/query/sqm/mutation/multitable/IdSelectionTests.java

@@ -52,7 +52,7 @@ public class IdSelectionTests {
 
 	@Test
 	public void testSecondaryTableRestrictedOnRootTable(SessionFactoryScope scope) {
-		final SqmDeleteStatement sqm = (SqmDeleteStatement) scope.getSessionFactory()
+		final SqmDeleteStatement<?> sqm = (SqmDeleteStatement<?>) scope.getSessionFactory()
 				.getQueryEngine()
 				.getHqlTranslator()
 				.translate( "delete SimpleEntityWithSecondaryTables where name = :n" );
@@ -77,7 +77,7 @@ public void testSecondaryTableRestrictedOnRootTable(SessionFactoryScope scope) {
 
 	@Test
 	public void testSecondaryTableRestrictedOnNonRootTable(SessionFactoryScope scope) {
-		final SqmDeleteStatement sqm = (SqmDeleteStatement) scope.getSessionFactory()
+		final SqmDeleteStatement<?> sqm = (SqmDeleteStatement<?>) scope.getSessionFactory()
 				.getQueryEngine()
 				.getHqlTranslator()
 				.translate( "delete SimpleEntityWithSecondaryTables where data = :d" );
@@ -102,7 +102,7 @@ public void testSecondaryTableRestrictedOnNonRootTable(SessionFactoryScope scope
 
 	@Test
 	public void testJoinedSubclassRestrictedOnRootTable(SessionFactoryScope scope) {
-		final SqmDeleteStatement sqm = (SqmDeleteStatement) scope.getSessionFactory()
+		final SqmDeleteStatement<?> sqm = (SqmDeleteStatement<?>) scope.getSessionFactory()
 				.getQueryEngine()
 				.getHqlTranslator()
 				.translate( "delete Customer where name = :n" );
@@ -127,7 +127,7 @@ public void testJoinedSubclassRestrictedOnRootTable(SessionFactoryScope scope) {
 
 	@Test
 	public void testJoinedSubclassRestrictedOnNonPrimaryRootTable(SessionFactoryScope scope) {
-		final SqmDeleteStatement sqm = (SqmDeleteStatement) scope.getSessionFactory()
+		final SqmDeleteStatement<?> sqm = (SqmDeleteStatement<?>) scope.getSessionFactory()
 				.getQueryEngine()
 				.getHqlTranslator()
 				.translate( "delete ForeignCustomer where name = :n" );
@@ -152,7 +152,7 @@ public void testJoinedSubclassRestrictedOnNonPrimaryRootTable(SessionFactoryScop
 
 	@Test
 	public void testJoinedSubclassRestrictedOnPrimaryNonRootTable(SessionFactoryScope scope) {
-		final SqmDeleteStatement sqm = (SqmDeleteStatement) scope.getSessionFactory()
+		final SqmDeleteStatement<?> sqm = (SqmDeleteStatement<?>) scope.getSessionFactory()
 				.getQueryEngine()
 				.getHqlTranslator()
 				.translate( "delete ForeignCustomer where vat = :v" );

hibernate-core/src/test/java/org/hibernate/orm/test/set/SetOperationJpaCriteriaTest.java

@@ -0,0 +1,163 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.orm.test.set;
+
+import java.util.List;
+
+import javax.persistence.Tuple;
+
+import org.hibernate.query.criteria.HibernateCriteriaBuilder;
+import org.hibernate.query.criteria.JpaCriteriaQuery;
+import org.hibernate.query.criteria.JpaRoot;
+
+import org.hibernate.testing.orm.domain.StandardDomainModel;
+import org.hibernate.testing.orm.domain.gambit.EntityOfLists;
+import org.hibernate.testing.orm.junit.DialectFeatureChecks;
+import org.hibernate.testing.orm.junit.DomainModel;
+import org.hibernate.testing.orm.junit.RequiresDialectFeature;
+import org.hibernate.testing.orm.junit.ServiceRegistry;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ *
+ * @author Christian Beikov
+ */
+@DomainModel( standardModels = StandardDomainModel.GAMBIT )
+@ServiceRegistry
+@SessionFactory
+public class SetOperationJpaCriteriaTest {
+    @BeforeEach
+    public void createTestData(SessionFactoryScope scope) {
+        scope.inTransaction(
+                session -> {
+                    session.save( new EntityOfLists( 1, "first" ) );
+                    session.save( new EntityOfLists( 2, "second" ) );
+                    session.save( new EntityOfLists( 3, "third" ) );
+                }
+        );
+    }
+
+    @AfterEach
+    public void dropTestData(SessionFactoryScope scope) {
+        scope.inTransaction(
+                session -> {
+                    session.createQuery( "delete from EntityOfLists" ).executeUpdate();
+                    session.createQuery( "delete from SimpleEntity" ).executeUpdate();
+                }
+        );
+    }
+
+    @Test
+    @RequiresDialectFeature(feature = DialectFeatureChecks.SupportsUnion.class)
+    public void testUnionAll(SessionFactoryScope scope) {
+        scope.inSession(
+                session -> {
+                    HibernateCriteriaBuilder cb = session.getCriteriaBuilder();
+
+                    JpaCriteriaQuery<EntityOfLists> query1 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root1 = query1.from( EntityOfLists.class );
+                    query1.where( cb.equal( root1.get( "id" ), 1 ) );
+
+                    JpaCriteriaQuery<EntityOfLists> query2 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root2 = query2.from( EntityOfLists.class );
+                    query2.where( cb.equal( root2.get( "id" ), 2 ) );
+
+                    List<EntityOfLists> list = session.createQuery(
+                            cb.unionAll( query1, query2 )
+                    ).list();
+                    assertThat( list.size(), is( 2 ) );
+                }
+        );
+    }
+
+    @Test
+    @RequiresDialectFeature(feature = DialectFeatureChecks.SupportsUnion.class)
+    public void testUnionAllLimit(SessionFactoryScope scope) {
+        scope.inSession(
+                session -> {
+                    HibernateCriteriaBuilder cb = session.getCriteriaBuilder();
+
+                    JpaCriteriaQuery<EntityOfLists> query1 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root1 = query1.from( EntityOfLists.class );
+                    query1.where( cb.equal( root1.get( "id" ), 1 ) );
+
+                    JpaCriteriaQuery<EntityOfLists> query2 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root2 = query2.from( EntityOfLists.class );
+                    query2.where( cb.equal( root2.get( "id" ), 2 ) );
+
+                    List<EntityOfLists> list = session.createQuery(
+                            cb.unionAll( query1, query2 )
+                                .orderBy( cb.asc( cb.literal( 1 ) ) )
+                                .fetch( 1 )
+                    ).list();
+                    assertThat( list.size(), is( 1 ) );
+                }
+        );
+    }
+
+    @Test
+    @RequiresDialectFeature(feature = DialectFeatureChecks.SupportsUnion.class)
+    public void testUnionAllLimitSubquery(SessionFactoryScope scope) {
+        scope.inSession(
+                session -> {
+                    HibernateCriteriaBuilder cb = session.getCriteriaBuilder();
+
+                    JpaCriteriaQuery<EntityOfLists> query1 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root1 = query1.from( EntityOfLists.class );
+                    query1.where( cb.equal( root1.get( "id" ), 1 ) );
+
+                    JpaCriteriaQuery<EntityOfLists> query2 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root2 = query2.from( EntityOfLists.class );
+                    query2.where( cb.equal( root2.get( "id" ), 2 ) );
+
+                    List<EntityOfLists> list = session.createQuery(
+                            cb.unionAll(
+                                    query1,
+                                    query2.orderBy( cb.asc( cb.literal( 1 ) ) )
+                                            .fetch( 1 )
+                            )
+                    ).list();
+                    assertThat( list.size(), is( 2 ) );
+                }
+        );
+    }
+
+    @Test
+    @RequiresDialectFeature(feature = DialectFeatureChecks.SupportsUnion.class)
+    public void testUnionAllLimitNested(SessionFactoryScope scope) {
+        scope.inSession(
+                session -> {
+                    HibernateCriteriaBuilder cb = session.getCriteriaBuilder();
+
+                    JpaCriteriaQuery<EntityOfLists> query1 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root1 = query1.from( EntityOfLists.class );
+                    query1.where( cb.equal( root1.get( "id" ), 1 ) );
+
+                    JpaCriteriaQuery<EntityOfLists> query2 = cb.createQuery( EntityOfLists.class );
+                    JpaRoot<EntityOfLists> root2 = query2.from( EntityOfLists.class );
+                    query2.where( cb.equal( root2.get( "id" ), 2 ) );
+
+                    List<EntityOfLists> list = session.createQuery(
+                            cb.unionAll(
+                                    query1,
+                                    query2.orderBy( cb.asc( cb.literal( 1 ) ) )
+                                            .fetch( 1 )
+                            ).orderBy( cb.asc( cb.literal( 1 ) ) )
+                                    .fetch( 1 )
+                    ).list();
+                    assertThat( list.size(), is( 1 ) );
+                }
+        );
+    }
+}

hibernate-core/src/test/java/org/hibernate/orm/test/sql/ast/SmokeTests.java

@@ -77,13 +77,12 @@ public void testSimpleHqlInterpretation(SessionFactoryScope scope) {
 							String.class
 					);
 					final HqlQueryImplementor<String> hqlQuery = (HqlQueryImplementor<String>) query;
-					//noinspection unchecked
 					final SqmSelectStatement<String> sqmStatement = (SqmSelectStatement<String>) hqlQuery.getSqmStatement();
 
 					final StandardSqmTranslator<SelectStatement> sqmConverter = new StandardSqmTranslator<>(
 							sqmStatement,
 							hqlQuery.getQueryOptions(),
-							( (QuerySqmImpl) hqlQuery ).getDomainParameterXref(),
+							( (QuerySqmImpl<?>) hqlQuery ).getDomainParameterXref(),
 							query.getParameterBindings(),
 							session.getLoadQueryInfluencers(),
 							scope.getSessionFactory()
@@ -138,13 +137,12 @@ public void testConvertedHqlInterpretation(SessionFactoryScope scope) {
 				session -> {
 					final QueryImplementor<Gender> query = session.createQuery( "select e.gender from SimpleEntity e", Gender.class );
 					final HqlQueryImplementor<Gender> hqlQuery = (HqlQueryImplementor<Gender>) query;
-					//noinspection unchecked
 					final SqmSelectStatement<Gender> sqmStatement = (SqmSelectStatement<Gender>) hqlQuery.getSqmStatement();
 
 					final StandardSqmTranslator<SelectStatement> sqmConverter = new StandardSqmTranslator<>(
 							sqmStatement,
 							hqlQuery.getQueryOptions(),
-							( (QuerySqmImpl) hqlQuery ).getDomainParameterXref(),
+							( (QuerySqmImpl<?>) hqlQuery ).getDomainParameterXref(),
 							query.getParameterBindings(),
 							session.getLoadQueryInfluencers(),
 							scope.getSessionFactory()

hibernate-core/src/test/java/org/hibernate/orm/test/sql/results/AbstractResultTests.java

@@ -28,7 +28,7 @@ protected SelectStatement interpret(String hql, SessionFactoryImplementor sessio
 	protected SelectStatement interpret(String hql, QueryParameterBindings parameterBindings, SessionFactoryImplementor sessionFactory) {
 		final QueryEngine queryEngine = sessionFactory.getQueryEngine();
 
-		final SqmSelectStatement sqm = (SqmSelectStatement) queryEngine.getHqlTranslator().translate( hql );
+		final SqmSelectStatement<?> sqm = (SqmSelectStatement<?>) queryEngine.getHqlTranslator().translate( hql );
 
 		final SqmTranslatorFactory sqmTranslatorFactory = queryEngine.getSqmTranslatorFactory();
 		final SqmTranslator<SelectStatement> sqmConverter = sqmTranslatorFactory.createSelectTranslator(

hibernate-core/src/test/java/org/hibernate/test/hql/ASTParserLoadingTest.java

@@ -269,19 +269,19 @@ public void testJpaTypeOperator() {
 					// select clause
 
 					// control
-					Query query = session.createQuery( "select a.class from Animal a where a.class = Dog" );
+					Query<?> query = session.createQuery( "select a.class from Animal a where a.class = Dog" );
 					query.list();
-					SqmSelectStatement sqmStatement = (SqmSelectStatement) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
+					SqmSelectStatement<?> sqmStatement = (SqmSelectStatement<?>) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
 					List<SqmSelection> selections = sqmStatement.getQuerySpec().getSelectClause().getSelections();
 					assertEquals( 1, selections.size() );
-					SqmSelection typeSelection = selections.get( 0 );
+					SqmSelection<?> typeSelection = selections.get( 0 );
 					// always integer for joined
 					assertEquals( Integer.class, typeSelection.getNodeJavaTypeDescriptor().getJavaType() );
 
 					// test
 					query = session.createQuery( "select type(a) from Animal a where type(a) = Dog" );
 					query.list();
-					sqmStatement = (SqmSelectStatement) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
+					sqmStatement = (SqmSelectStatement<?>) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
 					selections = sqmStatement.getQuerySpec().getSelectClause().getSelections();
 					assertEquals( 1, selections.size() );
 					typeSelection = selections.get( 0 );
@@ -1540,11 +1540,11 @@ public void testJPAPositionalParameterList() {
 	public void testComponentQueries() {
 		inTransaction(
 				session -> {
-					final QueryImplementor query = session.createQuery( "select h.name from Human h" );
+					final QueryImplementor<?> query = session.createQuery( "select h.name from Human h" );
-					final SqmSelectStatement sqmStatement = (SqmSelectStatement) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
+					final SqmSelectStatement<?> sqmStatement = (SqmSelectStatement<?>) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
 					assertEquals( 1, sqmStatement.getQuerySpec().getSelectClause().getSelections().size() );
-					final SqmSelection selection = sqmStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
+					final SqmSelection<?> selection = sqmStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
-					final SqmExpressable selectionType = selection.getSelectableNode().getNodeType();
+					final SqmExpressable<?> selectionType = selection.getSelectableNode().getNodeType();
 					assertThat( selectionType, CoreMatchers.instanceOf( EmbeddableDomainType.class ) );
 					assertEquals( Name.class, selection.getNodeJavaTypeDescriptor().getJavaType() );
 
@@ -1824,10 +1824,10 @@ public void testQueryMetadataRetrievalWithFetching() {
 		inSession(
 				session -> {
 					final Query query = session.createQuery( "from Animal a inner join fetch a.mother" );
-					final SqmSelectStatement sqmStatement = (SqmSelectStatement) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
+					final SqmSelectStatement<?> sqmStatement = (SqmSelectStatement<?>) query.unwrap( QuerySqmImpl.class ).getSqmStatement();
 					assertEquals( 1, sqmStatement.getQuerySpec().getSelectClause().getSelections().size() );
-					final SqmSelection selection = sqmStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
+					final SqmSelection<?> selection = sqmStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
-					final SqmExpressable selectionType = selection.getSelectableNode().getNodeType();
+					final SqmExpressable<?> selectionType = selection.getSelectableNode().getNodeType();
 					assertThat( selectionType, instanceOf( EntityDomainType.class ) );
 					assertThat( selectionType.getExpressableJavaTypeDescriptor().getJavaType(), equalTo( Animal.class ) );
 					assertThat( selection.getAlias(), is( "a" ) );
@@ -2148,15 +2148,15 @@ public void testSelectClauseImplicitJoin() {
 	}
 
 	private static void verifyAnimalZooSelection(Query q) {
-		final SqmSelectStatement sqmStatement = (SqmSelectStatement) q.unwrap( QuerySqmImpl.class ).getSqmStatement();
+		final SqmSelectStatement<?> sqmStatement = (SqmSelectStatement<?>) q.unwrap( QuerySqmImpl.class ).getSqmStatement();
-		final SqmSelection sqmSelection = sqmStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
+		final SqmSelection<?> sqmSelection = sqmStatement.getQuerySpec().getSelectClause().getSelections().get( 0 );
 		assertThat( sqmSelection.getSelectableNode(), instanceOf( SqmPath.class ) );
-		final SqmPath selectedPath = (SqmPath) sqmSelection.getSelectableNode();
+		final SqmPath<?> selectedPath = (SqmPath<?>) sqmSelection.getSelectableNode();
 		assertThat( selectedPath.getReferencedPathSource(), instanceOf( SingularPersistentAttribute.class ) );
 		final SingularPersistentAttribute selectedAttr = (SingularPersistentAttribute) selectedPath.getReferencedPathSource();
 		assertThat( selectedAttr.getName(), is( "zoo" ) );
 		assertThat( selectedAttr.getType(), instanceOf( EntityDomainType.class ) );
-		final EntityDomainType zooType = (EntityDomainType) selectedAttr.getType();
+		final EntityDomainType<?> zooType = (EntityDomainType<?>) selectedAttr.getType();
 		assertThat( zooType.getHibernateEntityName(), is( Zoo.class.getName() ) );
 	}
 
@@ -2596,15 +2596,15 @@ public void testAliases() {
 		a.setDescription("an animal");
 		s.persist(a);
 
-		Query q = s.createQuery( "select a.bodyWeight as abw, a.description from Animal a" );
+		Query<?> q = s.createQuery( "select a.bodyWeight as abw, a.description from Animal a" );
-		SqmSelectStatement sqmStatement = (SqmSelectStatement) q.unwrap( QuerySqmImpl.class ).getSqmStatement();
+		SqmSelectStatement<?> sqmStatement = (SqmSelectStatement<?>) q.unwrap( QuerySqmImpl.class ).getSqmStatement();
 		List<SqmSelection> selections = sqmStatement.getQuerySpec().getSelectClause().getSelections();
 		assertThat( selections.size(), is( 2 ) );
 		assertThat( selections.get( 0 ).getAlias(), is( "abw" ) );
 		assertThat( selections.get( 1 ).getAlias(), nullValue() );
 
 		q = s.createQuery("select count(*), avg(a.bodyWeight) as avg from Animal a");
-		sqmStatement = (SqmSelectStatement) q.unwrap( QuerySqmImpl.class ).getSqmStatement();
+		sqmStatement = (SqmSelectStatement<?>) q.unwrap( QuerySqmImpl.class ).getSqmStatement();
 		selections = sqmStatement.getQuerySpec().getSelectClause().getSelections();
 		assertThat( selections.size(), is( 2 ) );
 		assertThat( selections.get( 0 ), nullValue() );