HHH-3356 Support for normal and lateral subquery in from clause

Author: beikov

hibernate-core/src/main/antlr/org/hibernate/grammars/hql/HqlLexer.g4

@@ -207,6 +207,7 @@ IS					: [iI] [sS];
 JOIN				: [jJ] [oO] [iI] [nN];
 KEY					: [kK] [eE] [yY];
 LAST				: [lL] [aA] [sS] [tT];
+LATERAL				: [lL] [aA] [tT] [eE] [rR] [aA] [lL];
 LEADING				: [lL] [eE] [aA] [dD] [iI] [nN] [gG];
 LEFT				: [lL] [eE] [fF] [tT];
 LIKE				: [lL] [iI] [kK] [eE];

hibernate-core/src/main/antlr/org/hibernate/grammars/hql/HqlParser.g4

@@ -169,14 +169,15 @@ fromClause
  * The declaration of a root entity in 'from' clause, along with its joins
  */
 entityWithJoins
-	: rootEntity (join | crossJoin | jpaCollectionJoin)*
+	: fromRoot (join | crossJoin | jpaCollectionJoin)*
 	;
 
 /**
  * A root entity declaration in the 'from' clause, with optional identification variable
  */
-rootEntity
-	: entityName variable?
+fromRoot
+	: entityName variable?									# RootEntity
+	| LATERAL? LEFT_PAREN subquery RIGHT_PAREN variable?	# RootSubquery
 	;
 
 /**
@@ -212,7 +213,7 @@ jpaCollectionJoin
  * A 'join', with an optional 'on' or 'with' clause
  */
 join
-	: joinType JOIN FETCH? joinPath joinRestriction?
+	: joinType JOIN FETCH? joinTarget joinRestriction?
 	;
 
 /**
@@ -226,8 +227,9 @@ joinType
 /**
  * The joined path, with an optional identification variable
  */
-joinPath
-	: path variable?
+joinTarget
+	: path variable?										#JoinPath
+	| LATERAL? LEFT_PAREN subquery RIGHT_PAREN variable?	#JoinSubquery
 	;
 
 /**

hibernate-core/src/main/java/org/hibernate/dialect/AbstractHANADialect.java

@@ -1081,7 +1081,8 @@ public boolean supportsValuesListForInsert() {
 
 	@Override
 	public boolean supportsOrderByInSubquery() {
-		return false;
+		// Seems to work, though I don't know as of which version
+		return true;
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/dialect/DerbyDialect.java

@@ -577,7 +577,8 @@ public boolean supportsTupleDistinctCounts() {
 
 	@Override
 	public boolean supportsOrderByInSubquery() {
-		return false;
+		// As of version 10.5 Derby supports OFFSET and FETCH as well as ORDER BY in subqueries
+		return getVersion().isSameOrAfter( 10, 5 );
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/dialect/HANASqlAstTranslator.java

@@ -31,6 +31,8 @@
  */
 public class HANASqlAstTranslator<T extends JdbcOperation> extends AbstractSqlAstTranslator<T> {
 
+	private boolean inLateral;
+
 	public HANASqlAstTranslator(SessionFactoryImplementor sessionFactory, Statement statement) {
 		super( sessionFactory, statement );
 	}
@@ -64,7 +66,20 @@ public void visitQuerySpec(QuerySpec querySpec) {
 
 	@Override
 	public void visitQueryPartTableReference(QueryPartTableReference tableReference) {
-		emulateQueryPartTableReferenceColumnAliasing( tableReference );
+		if ( tableReference.isLateral() && !inLateral ) {
+			inLateral = true;
+			emulateQueryPartTableReferenceColumnAliasing( tableReference );
+			inLateral = false;
+		}
+		else {
+			emulateQueryPartTableReferenceColumnAliasing( tableReference );
+		}
+	}
+
+	@Override
+	protected SqlAstNodeRenderingMode getParameterRenderingMode() {
+		// HANA does not support parameters in lateral sub queries for some reason, so inline all the parameters in this case
+		return inLateral ? SqlAstNodeRenderingMode.INLINE_ALL_PARAMETERS : super.getParameterRenderingMode();
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/dialect/HSQLSqlAstTranslator.java

@@ -10,6 +10,8 @@
 import java.util.function.Consumer;
 
 import org.hibernate.engine.spi.SessionFactoryImplementor;
+import org.hibernate.metamodel.mapping.JdbcMapping;
+import org.hibernate.metamodel.mapping.JdbcMappingContainer;
 import org.hibernate.query.sqm.BinaryArithmeticOperator;
 import org.hibernate.query.sqm.ComparisonOperator;
 import org.hibernate.sql.ast.SqlAstNodeRenderingMode;
@@ -213,10 +215,15 @@ protected void renderSelectTupleComparison(
 	}
 
 	protected void renderComparison(Expression lhs, ComparisonOperator operator, Expression rhs) {
+		final JdbcMappingContainer lhsExpressionType = lhs.getExpressionType();
+		if ( lhsExpressionType == null ) {
+			renderComparisonStandard( lhs, operator, rhs );
+			return;
+		}
 		switch ( operator ) {
 			case DISTINCT_FROM:
 			case NOT_DISTINCT_FROM:
-				if ( lhs.getExpressionType().getJdbcMappings().get( 0 ).getJdbcType() instanceof ArrayJdbcType ) {
+				if ( lhsExpressionType.getJdbcMappings().get( 0 ).getJdbcType() instanceof ArrayJdbcType ) {
 					// HSQL implements distinct from semantics for arrays
 					lhs.accept( this );
 					appendSql( operator == ComparisonOperator.DISTINCT_FROM ? "<>" : "=" );

hibernate-core/src/main/java/org/hibernate/dialect/MariaDBSqlAstTranslator.java

@@ -132,6 +132,17 @@ protected boolean supportsRowValueConstructorSyntaxInQuantifiedPredicates() {
 		return false;
 	}
 
+	@Override
+	protected boolean supportsIntersect() {
+		return getDialect().getVersion().isSameOrAfter( 10, 3 );
+	}
+
+	@Override
+	protected boolean supportsDistinctFromPredicate() {
+		// It supports a proprietary operator
+		return true;
+	}
+
 	private boolean supportsWindowFunctions() {
 		return getDialect().getVersion().isSameOrAfter( 10, 2 );
 	}

hibernate-core/src/main/java/org/hibernate/dialect/MySQLSqlAstTranslator.java

@@ -149,6 +149,17 @@ protected boolean supportsRowValueConstructorSyntaxInQuantifiedPredicates() {
 		return false;
 	}
 
+	@Override
+	protected boolean supportsIntersect() {
+		return false;
+	}
+
+	@Override
+	protected boolean supportsDistinctFromPredicate() {
+		// It supports a proprietary operator
+		return true;
+	}
+
 	@Override
 	protected String getFromDual() {
 		return " from dual";

hibernate-core/src/main/java/org/hibernate/dialect/OracleSqlAstTranslator.java

@@ -11,6 +11,7 @@
 import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.internal.util.collections.Stack;
 import org.hibernate.metamodel.mapping.JdbcMapping;
+import org.hibernate.metamodel.mapping.JdbcMappingContainer;
 import org.hibernate.query.sqm.BinaryArithmeticOperator;
 import org.hibernate.query.sqm.ComparisonOperator;
 import org.hibernate.query.sqm.FetchClauseType;
@@ -354,12 +355,12 @@ public void visitOver(Over<?> over) {
 
 	@Override
 	protected void renderComparison(Expression lhs, ComparisonOperator operator, Expression rhs) {
-		if ( lhs.getExpressionType() == null ) {
+		final JdbcMappingContainer lhsExpressionType = lhs.getExpressionType();
+		if ( lhsExpressionType == null ) {
 			renderComparisonEmulateDecode( lhs, operator, rhs );
 			return;
 		}
-		final JdbcMapping lhsMapping = lhs.getExpressionType().getJdbcMappings().get( 0 );
-		switch ( lhsMapping.getJdbcType().getJdbcTypeCode() ) {
+		switch ( lhsExpressionType.getJdbcMappings().get( 0 ).getJdbcType().getJdbcTypeCode() ) {
 			case SqlTypes.SQLXML:
 				// In Oracle, XMLTYPE is not "comparable", so we have to use the xmldiff function for this purpose
 				switch ( operator ) {

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

@@ -8,7 +8,11 @@
 
 import java.util.List;
 
+import org.hibernate.Incubating;
 import org.hibernate.query.sqm.SqmExpressible;
+import org.hibernate.sql.ast.spi.FromClauseAccess;
+import org.hibernate.sql.ast.spi.SqlSelection;
+import org.hibernate.sql.ast.tree.from.TableGroupProducer;
 
 /**
  * Describes any structural type without a direct java type representation.
@@ -23,4 +27,12 @@ public interface TupleType<J> extends SqmExpressible<J> {
 
 	SqmExpressible<?> get(int index);
 	SqmExpressible<?> get(String componentName);
+
+	@Incubating
+	default TableGroupProducer resolveTableGroupProducer(
+			String aliasStem,
+			List<SqlSelection> sqlSelections,
+			FromClauseAccess fromClauseAccess) {
+		return null;
+	}
 }

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

@@ -0,0 +1,69 @@
+/*
+ * 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.metamodel.model.domain.internal;
+
+import org.hibernate.Incubating;
+import org.hibernate.engine.spi.IdentifierValue;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
+import org.hibernate.metamodel.mapping.BasicEntityIdentifierMapping;
+import org.hibernate.metamodel.mapping.JdbcMapping;
+import org.hibernate.property.access.spi.PropertyAccess;
+import org.hibernate.query.sqm.SqmExpressible;
+
+/**
+ * @author Christian Beikov
+ */
+@Incubating
+public class AnonymousTupleBasicEntityIdentifierMapping extends AnonymousTupleBasicValuedModelPart
+		implements BasicEntityIdentifierMapping {
+
+	private final BasicEntityIdentifierMapping delegate;
+
+	public AnonymousTupleBasicEntityIdentifierMapping(
+			String selectionExpression,
+			SqmExpressible<?> expressible,
+			JdbcMapping jdbcMapping,
+			BasicEntityIdentifierMapping delegate) {
+		super( delegate.getAttributeName(), selectionExpression, expressible, jdbcMapping );
+		this.delegate = delegate;
+	}
+
+	@Override
+	public IdentifierValue getUnsavedStrategy() {
+		return delegate.getUnsavedStrategy();
+	}
+
+	@Override
+	public Object getIdentifier(Object entity, SharedSessionContractImplementor session) {
+		return delegate.getIdentifier( entity, session );
+	}
+
+	@Override
+	public Object getIdentifier(Object entity) {
+		return delegate.getIdentifier( entity );
+	}
+
+	@Override
+	public void setIdentifier(Object entity, Object id, SharedSessionContractImplementor session) {
+		delegate.setIdentifier( entity, id, session );
+	}
+
+	@Override
+	public Object instantiate() {
+		return delegate.instantiate();
+	}
+
+	@Override
+	public PropertyAccess getPropertyAccess() {
+		return delegate.getPropertyAccess();
+	}
+
+	@Override
+	public String getAttributeName() {
+		return getPartName();
+	}
+}