HHH-15106 - fk() HQL function

Author: sebersole

hibernate-core/src/main/antlr/hql-sql.g

@@ -261,6 +261,15 @@ tokens
 		return dot;
 	}
 
+	protected AST lookupFkRefSource(AST path) throws SemanticException {
+		if ( path.getType() == DOT ) {
+			return lookupProperty( path, true, isInSelect() );
+		}
+		else {
+			return lookupNonQualifiedProperty( path );
+		}
+	}
+
 	protected boolean isNonQualifiedPropertyRef(AST ident) { return false; }
 
 	protected AST lookupNonQualifiedProperty(AST property) throws SemanticException { return property; }
@@ -746,12 +755,15 @@ identifier
 	;
 
 addrExpr! [ boolean root ]
-	: #(d:DOT lhs:addrExprLhs rhs:propertyName )	{
+	: #(d:DOT lhs:addrExprLhs rhs:propertyName ) {
 		// This gives lookupProperty() a chance to transform the tree 
 		// to process collection properties (.elements, etc).
 		#addrExpr = #(#d, #lhs, #rhs);
 		#addrExpr = lookupProperty(#addrExpr,root,false);
 	}
+	| fk_ref:fkRef {
+		#addrExpr = #fk_ref;
+	}
 	| #(i:INDEX_OP lhs2:addrExprLhs rhs2:expr [ null ])	{
 		#addrExpr = #(#i, #lhs2, #rhs2);
 		processIndex(#addrExpr);
@@ -776,6 +788,12 @@ addrExpr! [ boolean root ]
 	}
 	;
 
+fkRef
+	: #( r:FK_REF p:propertyRef ) {
+		#p = lookupProperty( #p, false, isInSelect() );
+	}
+	;
+
 addrExprLhs
 	: addrExpr [ false ]
 	;
@@ -785,7 +803,6 @@ propertyName
 	| CLASS
 	| ELEMENTS
 	| INDICES
-	| FK_REF
 	;
 
 propertyRef!
@@ -798,8 +815,7 @@ propertyRef!
 		#propertyRef = #(#d, #lhs, #rhs);
 		#propertyRef = lookupProperty(#propertyRef,false,true);
 	}
-	|
-	p:identifier {
+	| p:identifier {
 		// In many cases, things other than property-refs are recognized
 		// by this propertyRef rule.  Some of those I have seen:
 		//  1) select-clause from-aliases

hibernate-core/src/main/antlr/hql.g

@@ -46,6 +46,7 @@ tokens
 	EXISTS="exists";
 	FALSE="false";
 	FETCH="fetch";
+	FK_REF;
 	FROM="from";
 	FULL="full";
 	GROUP="group";
@@ -722,7 +723,8 @@ atom
 
 // level 0 - the basic element of an expression
 primaryExpression
-    : { validateSoftKeyword("function") && LA(2) == OPEN && LA(3) == QUOTED_STRING }? jpaFunctionSyntax
+    : { validateSoftKeyword("fk") && LA(2) == OPEN }? fkRefPath
+    | { validateSoftKeyword("function") && LA(2) == OPEN && LA(3) == QUOTED_STRING }? jpaFunctionSyntax
     | { validateSoftKeyword("cast") && LA(2) == OPEN }? castFunction
     | { validateSoftKeyword("size") && LA(2) == OPEN }? collectionSizeFunction
 	| identPrimary ( options {greedy=true;} : DOT^ "class" )?
@@ -731,6 +733,12 @@ primaryExpression
 	| OPEN! (expressionOrVector | subQuery) CLOSE!
 	;
 
+fkRefPath!
+	: "fk" OPEN p:identPrimary CLOSE {
+		#fkRefPath = #( [FK_REF], #p );
+	}
+	;
+
 jpaFunctionSyntax!
     : i:IDENT OPEN n:QUOTED_STRING (COMMA a:exprList)? CLOSE {
     	final String functionName = unquote( #n.getText() );
@@ -968,8 +976,6 @@ MOD: '%';
 COLON: ':';
 PARAM: '?';
 
-FK_REF: "{fk}";
-
 IDENT options { testLiterals=true; }
 	: ID_START_LETTER ( ID_LETTER )*
 		{

hibernate-core/src/main/antlr/sql-gen.g

@@ -509,6 +509,7 @@ parameter
 
 addrExpr
 	: #(r:DOT . .) { out(r); }
+	| #(fk:FK_REF .) { out(fk); }
 	| i:ALIAS_REF { out(i); }
 	| j:INDEX_OP { out(j); }
 	| v:RESULT_VARIABLE_REF { out(v); }

hibernate-core/src/main/java/org/hibernate/hql/internal/ast/SqlASTFactory.java

@@ -15,6 +15,7 @@
 import org.hibernate.hql.internal.ast.tree.BinaryLogicOperatorNode;
 import org.hibernate.hql.internal.ast.tree.BooleanLiteralNode;
 import org.hibernate.hql.internal.ast.tree.CastFunctionNode;
+import org.hibernate.hql.internal.ast.tree.FkRefNode;
 import org.hibernate.hql.internal.ast.tree.NullNode;
 import org.hibernate.hql.internal.ast.tree.SearchedCaseNode;
 import org.hibernate.hql.internal.ast.tree.SimpleCaseNode;
@@ -196,6 +197,9 @@ public Class getASTNodeType(int tokenType) {
 			case NULL : {
 				return NullNode.class;
 			}
+			case FK_REF: {
+				return FkRefNode.class;
+			}
 			default:
 				return SqlNode.class;
 		}

hibernate-core/src/main/java/org/hibernate/hql/internal/ast/tree/DotNode.java

@@ -65,8 +65,6 @@ public QueryException buildIllegalCollectionDereferenceException(String property
 	public static enum DereferenceType {
 		UNKNOWN,
 		ENTITY,
-		FK_REF,
-		FK_REF_LHS,
 		COMPONENT,
 		COLLECTION,
 		PRIMITIVE,
@@ -267,41 +265,6 @@ private void initText() {
 	private Type prepareLhs() throws SemanticException {
 		final FromReferenceNode lhs = getLhs();
 		lhs.prepareForDot( propertyName );
-
-		if ( "{fk}".equals( propertyName ) ) {
-			// we are processing the {fk} node and "preparing" its
-			// lhs, which is the to-one mapping.  it is significantly
-			// easiest to simply handle this case here.  The other
-			// option would be to muck around with the PropertyMapping
-			// for the entity containing the to-one to add mapping for
-			// the {fk} path; but unfortunately that still means
-			// additional changes here
-			final Type toOneType = lhs.getDataType();
-			assert toOneType instanceof EntityType;
-
-			dereferenceType = DereferenceType.FK_REF;
-
-			final String toOnePropertyPath;
-			if ( lhs instanceof DotNode ) {
-				final DotNode lhsAsDotNode = (DotNode) lhs;
-				toOnePropertyPath = lhsAsDotNode.propertyPath;
-			}
-			else {
-				assert lhs instanceof IdentNode;
-				final IdentNode lhsAsIdentNode = (IdentNode) lhs;
-				toOnePropertyPath = lhsAsIdentNode.getOriginalText();
-			}
-			propertyPath = toOnePropertyPath + ".{fk}";
-
-			// resolve the fk key columns
-			final String tableAlias = getLhs().getFromElement().getTableAlias();
-			this.columns = getFromElement().getElementType().toColumns( tableAlias, toOnePropertyPath, false );
-
-			// and the key type
-			final Type keyType = getFromElement().getElementType().getPropertyType( toOnePropertyPath, toOnePropertyPath );
-			setDataType( keyType );
-		}
-
 		return getDataType();
 	}
 
@@ -434,27 +397,9 @@ private void dereferenceEntity(
 
 			// our parent is another dot node, meaning we are being further de-referenced.
 			// depending on the exact de-reference we may need to generate a physical join.
-			// generally we will need the join unless:
-			//		* this is a to-one reference && either:
-			//			* the de-reference path is the associated entity's identifier
-			//				&& the to-one is not marked with @NotFound
-			//			* the de-reference is the special {fk} token
 
 			property = parentAsDotNode.propertyName;
 
-			if ( "{fk}".equals( property ) ) {
-				if ( parentAsDotNode.getNextSibling() != null ) {
-					throw new QueryException(
-							"{fk} reference cannot be further de-referenced - " + propertyPath + " -> " + parentAsDotNode.getNextSibling().getText()
-					);
-				}
-
-				dereferenceType = DereferenceType.FK_REF_LHS;
-
-//				dereferenceForeignKeyReference( toOneType, ( (DotNode) parentAsDotNode.getLhs() ).getPropertyPath() );
-				return;
-			}
-
 			if ( generateJoin ) {
 				if ( implicitJoin && ( toOneType.hasNotFoundAction() || toOneType.isNullable() ) ) {
 					joinIsNeeded = true;
@@ -497,25 +442,6 @@ private static boolean isDotNode(AST n) {
 		return n != null && n.getType() == SqlTokenTypes.DOT;
 	}
 
-	private void dereferenceForeignKeyReference(EntityType toOneType, String toOnePropertyName) throws SemanticException {
-		dereferenceType = DereferenceType.FK_REF;
-
-		if ( LOG.isDebugEnabled() ) {
-			LOG.debugf( "dereferenceForeignKeyReference() : %s", getPath() );
-		}
-
-		final String fkRefPath = propertyPath + ".{fk}";
-		propertyPath = fkRefPath;
-
-		// resolve the fk key columns
-		final String tableAlias = getLhs().getFromElement().getTableAlias();
-		this.columns = getFromElement().getElementType().toColumns( tableAlias, fkRefPath, false );
-
-		// and the key type
-		setDataType( getFromElement().getElementType().getPropertyType( toOnePropertyName, fkRefPath ) );
-	}
-
-
 	private void dereferenceEntityJoin(
 			String classAlias,
 			EntityType toOneType,

hibernate-core/src/main/java/org/hibernate/hql/internal/ast/tree/FkRefNode.java

@@ -0,0 +1,133 @@
+/*
+ * 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.hql.internal.ast.tree;
+
+import org.hibernate.QueryException;
+import org.hibernate.hql.internal.ast.InvalidPathException;
+import org.hibernate.type.BasicType;
+import org.hibernate.type.CompositeType;
+import org.hibernate.type.ManyToOneType;
+import org.hibernate.type.Type;
+
+import antlr.SemanticException;
+import antlr.collections.AST;
+
+/**
+ * Represents a `fk()` pseudo-function
+ *
+ * @author Steve Ebersole
+ */
+public class FkRefNode
+		extends HqlSqlWalkerNode
+		implements ResolvableNode, DisplayableNode, PathNode {
+	private FromReferenceNode toOnePath;
+
+	private Type fkType;
+	private String[] columns;
+
+	private FromReferenceNode resolveToOnePath() {
+		if ( toOnePath == null ) {
+			try {
+				resolve( false, true );
+			}
+			catch (SemanticException e) {
+				final String msg = "Unable to resolve to-one path `fk(" + toOnePath.getPath() + "`)";
+				throw new QueryException( msg, new InvalidPathException( msg ) );
+			}
+		}
+
+		assert toOnePath != null;
+		return toOnePath;
+	}
+
+	@Override
+	public String getDisplayText() {
+		final FromReferenceNode toOnePath = resolveToOnePath();
+		return "fk(`" + toOnePath.getDisplayText() + "` )";
+	}
+
+	@Override
+	public String getPath() {
+		return toOnePath.getDisplayText() + ".{fk}";
+	}
+
+	@Override
+	public void resolve(
+			boolean generateJoin,
+			boolean implicitJoin) throws SemanticException {
+		if ( toOnePath != null ) {
+			return;
+		}
+
+		final AST firstChild = getFirstChild();
+		assert firstChild instanceof FromReferenceNode;
+
+		toOnePath = (FromReferenceNode) firstChild;
+		toOnePath.resolve( false, true, null, toOnePath.getFromElement() );
+
+		final Type sourcePathDataType = toOnePath.getDataType();
+		if ( ! ( sourcePathDataType instanceof ManyToOneType ) ) {
+			throw new InvalidPathException(
+					"Argument to fk() function must be a to-one path, but found " + sourcePathDataType
+			);
+		}
+		final ManyToOneType toOneType = (ManyToOneType) sourcePathDataType;
+		final FromElement fromElement = toOnePath.getFromElement();
+
+		fkType = toOneType.getIdentifierOrUniqueKeyType( getSessionFactoryHelper().getFactory() );
+		assert fkType instanceof BasicType
+				|| fkType instanceof CompositeType;
+
+		columns = fromElement.getElementType().toColumns(
+				fromElement.getTableAlias(),
+				toOneType.getPropertyName(),
+				getWalker().isInSelect()
+		);
+		assert columns != null && columns.length > 0;
+
+		setText( String.join( ", ", columns ) );
+	}
+
+	@Override
+	public void resolve(
+			boolean generateJoin,
+			boolean implicitJoin,
+			String classAlias,
+			AST parent,
+			AST parentPredicate) throws SemanticException {
+		resolve( false, true );
+	}
+
+	@Override
+	public void resolve(
+			boolean generateJoin,
+			boolean implicitJoin,
+			String classAlias,
+			AST parent) throws SemanticException {
+		resolve( false, true );
+	}
+
+	@Override
+	public void resolve(
+			boolean generateJoin,
+			boolean implicitJoin,
+			String classAlias) throws SemanticException {
+		resolve( false, true );
+	}
+
+	@Override
+	public void resolveInFunctionCall(
+			boolean generateJoin,
+			boolean implicitJoin) throws SemanticException {
+		resolve( false, true );
+	}
+
+	@Override
+	public void resolveIndex(AST parent) throws SemanticException {
+		throw new InvalidPathException( "fk() paths cannot be de-referenced as indexed path" );
+	}
+}