| /* |
| * Copyright (c) 2006, 2021 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Oracle - initial API and implementation |
| // |
| // 09/02/2019-3.0 Alexandre Jacob |
| // - 527415: Fix code when locale is tr, az or lt |
| package org.eclipse.persistence.jpa.jpql.tools.resolver; |
| |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.persistence.jpa.jpql.ExpressionTools; |
| import org.eclipse.persistence.jpa.jpql.LiteralType; |
| import org.eclipse.persistence.jpa.jpql.parser.AbstractExpressionVisitor; |
| import org.eclipse.persistence.jpa.jpql.parser.AbstractSchemaName; |
| import org.eclipse.persistence.jpa.jpql.parser.AnonymousExpressionVisitor; |
| import org.eclipse.persistence.jpa.jpql.parser.CollectionExpression; |
| import org.eclipse.persistence.jpa.jpql.parser.CollectionMemberDeclaration; |
| import org.eclipse.persistence.jpa.jpql.parser.CollectionValuedPathExpression; |
| import org.eclipse.persistence.jpa.jpql.parser.DeleteClause; |
| import org.eclipse.persistence.jpa.jpql.parser.DeleteStatement; |
| import org.eclipse.persistence.jpa.jpql.parser.Expression; |
| import org.eclipse.persistence.jpa.jpql.parser.FromClause; |
| import org.eclipse.persistence.jpa.jpql.parser.IdentificationVariable; |
| import org.eclipse.persistence.jpa.jpql.parser.IdentificationVariableDeclaration; |
| import org.eclipse.persistence.jpa.jpql.parser.JPQLExpression; |
| import org.eclipse.persistence.jpa.jpql.parser.Join; |
| import org.eclipse.persistence.jpa.jpql.parser.NullExpression; |
| import org.eclipse.persistence.jpa.jpql.parser.RangeVariableDeclaration; |
| import org.eclipse.persistence.jpa.jpql.parser.ResultVariable; |
| import org.eclipse.persistence.jpa.jpql.parser.SelectClause; |
| import org.eclipse.persistence.jpa.jpql.parser.SelectStatement; |
| import org.eclipse.persistence.jpa.jpql.parser.SimpleFromClause; |
| import org.eclipse.persistence.jpa.jpql.parser.SimpleSelectClause; |
| import org.eclipse.persistence.jpa.jpql.parser.SimpleSelectStatement; |
| import org.eclipse.persistence.jpa.jpql.parser.SubExpression; |
| import org.eclipse.persistence.jpa.jpql.parser.UpdateClause; |
| import org.eclipse.persistence.jpa.jpql.parser.UpdateStatement; |
| import org.eclipse.persistence.jpa.jpql.tools.JPQLQueryContext; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IMapping; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IQuery; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IType; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.ITypeDeclaration; |
| |
| /** |
| * This {@link Resolver} is responsible to visit the current query (which is either the top-level |
| * query or a subquery) and gathers the information from the declaration clause. For a <b>SELECT</b> |
| * or <b>DELETE</b> clause, the information will be retrieved from the <b>FROM</b> clause. For an |
| * <code>UDPATE</code> clause, it will be retrieved from the unique identification range variable |
| * declaration. |
| * |
| * @version 2.5 |
| * @since 2.3 |
| * @author Pascal Filion |
| */ |
| public class DeclarationResolver extends Resolver { |
| |
| /** |
| * The {@link Declaration Declarations} of the current query that was parsed. |
| */ |
| private List<Declaration> declarations; |
| |
| /** |
| * This visitor is responsible to visit the current query's declaration and populate this |
| * resolver with the list of declarations. |
| */ |
| private DeclarationVisitor declarationVisitor; |
| |
| /** |
| * This visitor is responsible to convert the abstract schema name into a path expression. |
| */ |
| private QualifyRangeDeclarationVisitor qualifyRangeDeclarationVisitor; |
| |
| /** |
| * The context used to query information about the query. |
| */ |
| private JPQLQueryContext queryContext; |
| |
| /** |
| * The identification variable names mapped to their resolvers. |
| */ |
| private Map<String, Resolver> resolvers; |
| |
| /** |
| * The variables identifying the select expressions, if any was defined or an empty set if none |
| * were defined. |
| */ |
| private Map<IdentificationVariable, String> resultVariables; |
| |
| /** |
| * This visitor resolves the "root" object represented by the given {@link Expression}. This will |
| * also handle using a subquery in the <code><b>FROM</b></code> clause. This is only supported by |
| * EclipseLink. |
| */ |
| private RootObjectExpressionVisitor rootObjectExpressionVisitor; |
| |
| /** |
| * Creates a new <code>DeclarationResolver</code>. |
| * |
| * @param parent The parent resolver if this is used for a subquery or null if it's used for the |
| * top-level query |
| * @param queryContext The context used to query information about the query |
| */ |
| public DeclarationResolver(DeclarationResolver parent, JPQLQueryContext queryContext) { |
| super(parent); |
| initialize(queryContext); |
| } |
| |
| /** |
| * Adds the given {@link Declaration} at the end of the list. |
| * |
| * @param declaration The {@link Declaration} representing a single variable declaration |
| */ |
| protected final void addDeclaration(Declaration declaration) { |
| declarations.add(declaration); |
| } |
| |
| /** |
| * Registers a range variable declaration that will be used when a JPQL fragment is parsed. |
| * |
| * @param entityName The name of the entity to be accessible with the given variable name |
| * @param variableName The identification variable used to navigate to the entity |
| */ |
| public void addRangeVariableDeclaration(String entityName, String variableName) { |
| |
| // Always make the identification variable be upper case since it's |
| // case insensitive, the get will also use upper case |
| String internalVariableName = variableName.toUpperCase(Locale.ROOT); |
| |
| // Make sure the identification variable was not declared more than once, |
| // this could cause issues when trying to resolve it |
| if (!resolvers.containsKey(internalVariableName)) { |
| |
| // Resolve the expression and map it with the identification variable |
| Resolver resolver = new EntityResolver(this, entityName); |
| resolver = new IdentificationVariableResolver(resolver, variableName); |
| resolvers.put(internalVariableName, resolver); |
| |
| RangeDeclaration declaration = new RangeDeclaration(); |
| declaration.rootPath = entityName; |
| declaration.identificationVariable = new IdentificationVariable(null, variableName); |
| declarations.add(declaration); |
| } |
| } |
| |
| protected DeclarationVisitor buildDeclarationVisitor() { |
| return new DeclarationVisitor(); |
| } |
| |
| protected RootObjectExpressionVisitor buildRootObjectExpressionVisitor() { |
| return new RootObjectExpressionVisitor(); |
| } |
| |
| @Override |
| protected IType buildType() { |
| return getTypeHelper().unknownType(); |
| } |
| |
| @Override |
| protected ITypeDeclaration buildTypeDeclaration() { |
| return getTypeHelper().unknownTypeDeclaration(); |
| } |
| |
| @Override |
| protected void checkParent(Resolver parent) { |
| // Don't do anything, this is the root |
| } |
| |
| /** |
| * Converts the given {@link Declaration} from being set as a range variable declaration to |
| * a path expression declaration. |
| * <p> |
| * In this query "<code>UPDATE Employee SET firstName = 'MODIFIED' WHERE (SELECT COUNT(m) FROM |
| * managedEmployees m) {@literal >} 0</code>" <em>managedEmployees</em> is an unqualified |
| * collection-valued path expression (<code>employee.managedEmployees</code>). |
| * |
| * @param declaration The {@link Declaration} that was parsed to range over an abstract schema |
| * name but is actually ranging over a path expression |
| * @param outerVariableName The identification variable coming from the parent identification |
| * variable declaration |
| */ |
| public void convertUnqualifiedDeclaration(Declaration declaration, String outerVariableName) { |
| |
| QualifyRangeDeclarationVisitor visitor = qualifyRangeDeclarationVisitor(); |
| |
| try { |
| visitor.oldDeclaration = declaration; |
| visitor.outerVariableName = outerVariableName; |
| |
| declaration.declarationExpression.accept(visitor); |
| } |
| finally { |
| visitor.oldDeclaration = null; |
| visitor.newDeclaration = null; |
| visitor.outerVariableName = null; |
| } |
| } |
| |
| /** |
| * Disposes the internal data. |
| */ |
| public void dispose() { |
| resolvers .clear(); |
| declarations .clear(); |
| resultVariables.clear(); |
| } |
| |
| /** |
| * Retrieves the {@link Declaration} for which the given variable name is used to navigate to the |
| * "root" object. |
| * |
| * @param variableName The name of the identification variable that is used to navigate a "root" object |
| * @return The {@link Declaration} containing the information about the identification variable declaration |
| * @since 2.5 |
| */ |
| public Declaration getDeclaration(String variableName) { |
| |
| for (Declaration declaration : declarations) { |
| if (declaration.getVariableName().equalsIgnoreCase(variableName)) { |
| return declaration; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the ordered list of {@link Declaration Declarations}. |
| * |
| * @return The {@link Declaration Declarations} of the current query that was parsed |
| */ |
| public List<Declaration> getDeclarations() { |
| return declarations; |
| } |
| |
| protected DeclarationVisitor getDeclarationVisitor() { |
| if (declarationVisitor == null) { |
| declarationVisitor = buildDeclarationVisitor(); |
| } |
| return declarationVisitor; |
| } |
| |
| @Override |
| public DeclarationResolver getParent() { |
| return (DeclarationResolver) super.getParent(); |
| } |
| |
| @Override |
| public IQuery getQuery() { |
| return queryContext.getQuery(); |
| } |
| |
| /** |
| * Returns the {@link JPQLQueryContext} that is used by this visitor. |
| * |
| * @return The {@link JPQLQueryContext} holding onto the JPQL query and the cached information |
| */ |
| protected JPQLQueryContext getQueryContext() { |
| return queryContext; |
| } |
| |
| /** |
| * Retrieves the {@link Resolver} mapped with the given identification variable. If the |
| * identification is not defined in the declaration traversed by this resolver, than the search |
| * will traverse the parent hierarchy. |
| * |
| * @param variableName The identification variable that maps a {@link Resolver} |
| * @return The {@link Resolver} mapped with the given identification variable |
| */ |
| public Resolver getResolver(String variableName) { |
| |
| variableName = variableName.toUpperCase(Locale.ROOT); |
| Resolver resolver = getResolverImp(variableName); |
| |
| if ((resolver == null) && (getParent() != null)) { |
| resolver = getParent().getResolver(variableName); |
| } |
| |
| if (resolver == null) { |
| resolver = new NullResolver(this); |
| resolvers.put(variableName, resolver); |
| } |
| |
| return resolver; |
| } |
| |
| /** |
| * Retrieves the {@link Resolver} mapped with the given identification variable. The search does |
| * not traverse the parent hierarchy. |
| * |
| * @param variableName The identification variable that maps a {@link Resolver} |
| * @return The {@link Resolver} mapped with the given identification variable |
| */ |
| protected Resolver getResolverImp(String variableName) { |
| return resolvers.get(variableName); |
| } |
| |
| /** |
| * Returns the variables that got defined in the select expression. This only applies to JPQL |
| * queries built for JPA 2.0 or later. |
| * |
| * @return The variables identifying the select expressions, if any was defined or an empty set |
| * if none were defined |
| */ |
| public Set<String> getResultVariables() { |
| return new HashSet<String>(resultVariables.values()); |
| } |
| |
| /** |
| * Returns the map of result variables that got used to define a select expression. This only |
| * applies to JPQL queries built for JPA 2.0. |
| * |
| * @return The variables identifying the select expressions, if any was defined or an empty map |
| * if none were defined |
| */ |
| public Map<IdentificationVariable, String> getResultVariablesMap() { |
| return resultVariables; |
| } |
| |
| protected RootObjectExpressionVisitor getRootObjectExpressionVisitor() { |
| if (rootObjectExpressionVisitor == null) { |
| rootObjectExpressionVisitor = buildRootObjectExpressionVisitor(); |
| } |
| return rootObjectExpressionVisitor; |
| } |
| |
| /** |
| * Determines whether the JPQL expression has <b>JOIN</b> expressions. |
| * |
| * @return <code>true</code> if the query or subquery being traversed contains <b>JOIN</b> |
| * expressions; <code>false</code> otherwise |
| */ |
| public boolean hasJoins() { |
| |
| for (Declaration declaration : declarations) { |
| if (declaration.hasJoins()) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Initializes this <code>DeclarationResolver</code>. |
| * |
| * @param queryContext The context used to query information about the query |
| */ |
| protected void initialize(JPQLQueryContext queryContext) { |
| this.queryContext = queryContext; |
| this.resolvers = new HashMap<String, Resolver>(); |
| this.declarations = new LinkedList<Declaration>(); |
| this.resultVariables = new HashMap<IdentificationVariable, String>(); |
| } |
| |
| /** |
| * Determines whether the given identification variable is defining a <b>JOIN</b> expression or |
| * in a <code>IN</code> expressions for a collection-valued field. If the search didn't find the |
| * identification in this resolver, then it will traverse the parent hierarchy. |
| * |
| * @param variableName The identification variable to check for what it maps |
| * @return <code>true</code> if the given identification variable maps a collection-valued field |
| * defined in a <code>JOIN</code> or <code>IN</code> expression; <code>false</code> otherwise |
| */ |
| public boolean isCollectionIdentificationVariable(String variableName) { |
| |
| boolean result = isCollectionIdentificationVariableImp(variableName); |
| |
| if (!result && (getParent() != null)) { |
| result = getParent().isCollectionIdentificationVariableImp(variableName); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Determines whether the given identification variable is defining a <b>JOIN</b> expression or |
| * in a <code>IN</code> expressions for a collection-valued field. The search does not traverse |
| * the parent hierarchy. |
| * |
| * @param variableName The identification variable to check for what it maps |
| * @return <code>true</code> if the given identification variable maps a collection-valued field |
| * defined in a <code>JOIN</code> or <code>IN</code> expression; <code>false</code> otherwise |
| */ |
| protected boolean isCollectionIdentificationVariableImp(String variableName) { |
| |
| for (Declaration declaration : declarations) { |
| |
| switch (declaration.getType()) { |
| |
| case COLLECTION: { |
| if (declaration.getVariableName().equalsIgnoreCase(variableName)) { |
| return true; |
| } |
| return false; |
| } |
| |
| case RANGE: |
| case DERIVED: { |
| |
| AbstractRangeDeclaration rangeDeclaration = (AbstractRangeDeclaration) declaration; |
| |
| // Check the JOIN expressions |
| for (Join join : rangeDeclaration.getJoins()) { |
| |
| String joinVariableName = queryContext.literal( |
| join.getIdentificationVariable(), |
| LiteralType.IDENTIFICATION_VARIABLE |
| ); |
| |
| if (joinVariableName.equalsIgnoreCase(variableName)) { |
| // Make sure the JOIN expression maps a collection mapping |
| Resolver resolver = getResolver(variableName); |
| IMapping mapping = (resolver != null) ? resolver.getMapping() : null; |
| return (mapping != null) && mapping.isCollection(); |
| } |
| } |
| } |
| |
| default: |
| continue; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Determines whether the given variable name is an identification variable name mapping an |
| * entity. The search traverses the parent resolver if it is not found in this resolver, which |
| * represents the current JPQL query. |
| * |
| * @param variableName The name of the variable to verify if it's defined in a range variable |
| * declaration in the current query or any parent query |
| * @return <code>true</code> if the variable name is mapping an abstract schema name; <code>false</code> |
| * if it's defined in a collection member declaration |
| */ |
| public boolean isRangeIdentificationVariable(String variableName) { |
| |
| boolean result = isRangeIdentificationVariableImp(variableName); |
| |
| if (!result && (getParent() != null)) { |
| result = getParent().isRangeIdentificationVariableImp(variableName); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Determines whether the given variable name is an identification variable name mapping an |
| * entity. The search only searches in this resolver, which represents the current JPQL query. |
| * |
| * @param variableName The name of the variable to verify if it's defined in a range variable |
| * declaration in the current query or any parent query |
| * @return <code>true</code> if the variable name is mapping an abstract schema name; <code>false</code> |
| * if it's defined in a collection member declaration |
| */ |
| protected boolean isRangeIdentificationVariableImp(String variableName) { |
| |
| for (Declaration declaration : declarations) { |
| |
| if (declaration.getType().isRange() && |
| declaration.getVariableName().equalsIgnoreCase(variableName)) { |
| |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Determines if the given variable is a result variable. |
| * |
| * @param variable The variable to check if it's a result variable |
| * @return <code>true</code> if the given variable is defined as a result variable; <code>false</code> |
| * otherwise |
| */ |
| public boolean isResultVariable(String variable) { |
| return resultVariables.containsValue(variable.toUpperCase(Locale.ROOT)); |
| } |
| |
| /** |
| * Visits the current query (which is either the top-level query or a subquery) and gathers the |
| * information from the declaration clause. |
| * |
| * @param expression The {@link Expression} to visit in order to retrieve the information |
| * contained in the given query's declaration |
| */ |
| public void populate(Expression expression) { |
| DeclarationVisitor visitor = getDeclarationVisitor(); |
| try { |
| expression.accept(visitor); |
| } |
| finally { |
| visitor.currentDeclaration = null; |
| } |
| } |
| |
| protected QualifyRangeDeclarationVisitor qualifyRangeDeclarationVisitor() { |
| if (qualifyRangeDeclarationVisitor == null) { |
| qualifyRangeDeclarationVisitor = new QualifyRangeDeclarationVisitor(); |
| } |
| return qualifyRangeDeclarationVisitor; |
| } |
| |
| /** |
| * Resolves the "root" object represented by the given {@link Expression}. This will also handle |
| * using a subquery in the <code><b>FROM</b></code> clause. This is only supported by EclipseLink. |
| * |
| * @param expression The {@link Expression} to visit, which represents the "root" object of a |
| * declaration |
| * @return The {@link Resolver} for the given {@link Expression} |
| */ |
| protected Resolver resolveRootObject(Expression expression) { |
| RootObjectExpressionVisitor visitor = getRootObjectExpressionVisitor(); |
| try { |
| expression.accept(visitor); |
| return visitor.resolver; |
| } |
| finally { |
| visitor.resolver = null; |
| } |
| } |
| |
| protected String visitDeclaration(Expression expression, Expression identificationVariable) { |
| |
| // Visit the identification variable expression and retrieve the identification variable name |
| String variableName = queryContext.literal( |
| identificationVariable, |
| LiteralType.IDENTIFICATION_VARIABLE |
| ); |
| |
| // If it's not empty, then we can create a Resolver |
| if (variableName != ExpressionTools.EMPTY_STRING) { |
| |
| // Always make the identification variable be upper case since it's |
| // case insensitive, the get will also use upper case |
| String internalVariableName = variableName.toUpperCase(Locale.ROOT); |
| |
| // Make sure the identification variable was not declared more than once, |
| // this could cause issues when trying to resolve it |
| if (!resolvers.containsKey(internalVariableName)) { |
| |
| // Resolve the expression and map it with the identification variable |
| Resolver resolver = resolveRootObject(expression); |
| resolver = new IdentificationVariableResolver(resolver, variableName); |
| resolvers.put(internalVariableName, resolver); |
| } |
| |
| return variableName; |
| } |
| |
| return ExpressionTools.EMPTY_STRING; |
| } |
| |
| protected class DeclarationVisitor extends AbstractExpressionVisitor { |
| |
| /** |
| * This flag is used to determine what to do in {@link #visit(SimpleSelectStatement)}. |
| */ |
| protected boolean buildingDeclaration; |
| |
| /** |
| * Flag used to determine if the {@link IdentificationVariable} to visit is a result variable. |
| */ |
| protected boolean collectResultVariable; |
| |
| /** |
| * The {@link Declaration} being populated. |
| */ |
| protected Declaration currentDeclaration; |
| |
| @Override |
| public void visit(AbstractSchemaName expression) { |
| currentDeclaration = new RangeDeclaration(); |
| currentDeclaration.rootPath = expression.getText(); |
| declarations.add(currentDeclaration); |
| } |
| |
| @Override |
| public void visit(CollectionExpression expression) { |
| expression.acceptChildren(this); |
| } |
| |
| @Override |
| public void visit(CollectionMemberDeclaration expression) { |
| |
| CollectionDeclaration declaration = new CollectionDeclaration(); |
| declaration.declarationExpression = expression; |
| declaration.baseExpression = expression.getCollectionValuedPathExpression(); |
| declaration.rootPath = declaration.baseExpression.toActualText(); |
| declarations.add(declaration); |
| |
| // Retrieve the IdentificationVariable |
| Expression identificationVariable = expression.getIdentificationVariable(); |
| String variableName = visitDeclaration(expression, identificationVariable); |
| |
| if (variableName != ExpressionTools.EMPTY_STRING) { |
| declaration.identificationVariable = (IdentificationVariable) identificationVariable; |
| } |
| } |
| |
| @Override |
| public void visit(CollectionValuedPathExpression expression) { |
| currentDeclaration = new DerivedDeclaration(); |
| currentDeclaration.rootPath = expression.toActualText(); |
| declarations.add(currentDeclaration); |
| } |
| |
| @Override |
| public void visit(DeleteClause expression) { |
| |
| try { |
| buildingDeclaration = true; |
| expression.getRangeVariableDeclaration().accept(this); |
| buildingDeclaration = false; |
| |
| currentDeclaration.declarationExpression = expression; |
| } |
| finally { |
| currentDeclaration = null; |
| } |
| } |
| |
| @Override |
| public void visit(DeleteStatement expression) { |
| expression.getDeleteClause().accept(this); |
| } |
| |
| @Override |
| public void visit(FromClause expression) { |
| expression.getDeclaration().accept(this); |
| } |
| |
| @Override |
| public void visit(IdentificationVariable expression) { |
| if (collectResultVariable) { |
| resultVariables.put(expression, expression.getText().toUpperCase(Locale.ROOT)); |
| } |
| } |
| |
| @Override |
| public void visit(IdentificationVariableDeclaration expression) { |
| |
| try { |
| expression.getRangeVariableDeclaration().accept(this); |
| expression.getJoins().accept(this); |
| currentDeclaration.declarationExpression = expression; |
| } |
| finally { |
| currentDeclaration = null; |
| } |
| } |
| |
| @Override |
| public void visit(Join expression) { |
| |
| AbstractRangeDeclaration rangeDeclaration = (AbstractRangeDeclaration) currentDeclaration; |
| Expression identificationVariable = expression.getIdentificationVariable(); |
| visitDeclaration(expression, identificationVariable); |
| rangeDeclaration.addJoin(expression); |
| } |
| |
| @Override |
| public void visit(JPQLExpression expression) { |
| expression.getQueryStatement().accept(this); |
| } |
| |
| @Override |
| public void visit(NullExpression expression) { |
| if (buildingDeclaration) { |
| currentDeclaration = new UnknownDeclaration(); |
| currentDeclaration.baseExpression = expression; |
| currentDeclaration.rootPath = ExpressionTools.EMPTY_STRING; |
| declarations.add(currentDeclaration); |
| } |
| } |
| |
| @Override |
| public void visit(RangeVariableDeclaration expression) { |
| |
| // Visit the "root" object, which will create the right Declaration |
| Expression rootObject = expression.getRootObject(); |
| buildingDeclaration = true; |
| rootObject.accept(this); |
| buildingDeclaration = false; |
| |
| // Set the base expression |
| currentDeclaration.baseExpression = expression; |
| |
| // Set the identification variable |
| Expression identificationVariable = expression.getIdentificationVariable(); |
| String variableName = visitDeclaration(rootObject, identificationVariable); |
| |
| if (variableName != ExpressionTools.EMPTY_STRING) { |
| currentDeclaration.identificationVariable = (IdentificationVariable) identificationVariable; |
| } |
| } |
| |
| @Override |
| public void visit(ResultVariable expression) { |
| collectResultVariable = true; |
| expression.getResultVariable().accept(this); |
| collectResultVariable = false; |
| } |
| |
| @Override |
| public void visit(SelectClause expression) { |
| expression.getSelectExpression().accept(this); |
| } |
| |
| @Override |
| public void visit(SelectStatement expression) { |
| expression.getFromClause().accept(this); |
| expression.getSelectClause().accept(this); |
| } |
| |
| @Override |
| public void visit(SimpleFromClause expression) { |
| expression.getDeclaration().accept(this); |
| } |
| |
| @Override |
| public void visit(SimpleSelectClause expression) { |
| expression.getSelectExpression().accept(this); |
| } |
| |
| @Override |
| public void visit(SimpleSelectStatement expression) { |
| expression.getFromClause().accept(this); |
| } |
| |
| @Override |
| public void visit(UpdateClause expression) { |
| |
| try { |
| buildingDeclaration = true; |
| expression.getRangeVariableDeclaration().accept(this); |
| buildingDeclaration = false; |
| |
| currentDeclaration.declarationExpression = expression; |
| } |
| finally { |
| currentDeclaration = null; |
| } |
| } |
| |
| @Override |
| public void visit(UpdateStatement expression) { |
| expression.getUpdateClause().accept(this); |
| } |
| } |
| |
| protected static class QualifyRangeDeclarationVisitor extends AbstractExpressionVisitor { |
| |
| /** |
| * The new {@link Declaration}. |
| */ |
| protected Declaration newDeclaration; |
| |
| /** |
| * The {@link Declaration} being modified. |
| */ |
| protected Declaration oldDeclaration; |
| |
| /** |
| * The identification variable coming from the parent identification variable declaration. |
| */ |
| protected String outerVariableName; |
| |
| @Override |
| public void visit(CollectionValuedPathExpression expression) { |
| newDeclaration.rootPath = expression.toActualText(); |
| newDeclaration.baseExpression = expression; |
| } |
| |
| @Override |
| public void visit(IdentificationVariableDeclaration expression) { |
| expression.getRangeVariableDeclaration().accept(this); |
| } |
| |
| @Override |
| public void visit(RangeVariableDeclaration expression) { |
| |
| newDeclaration = new DerivedDeclaration(); |
| |
| expression.setVirtualIdentificationVariable(outerVariableName, newDeclaration.rootPath); |
| expression.getRootObject().accept(this); |
| } |
| } |
| |
| /** |
| * This visitor takes care to support a subquery defined as a "root" object. |
| */ |
| protected class RootObjectExpressionVisitor extends AnonymousExpressionVisitor { |
| |
| /** |
| * The {@link Resolver} of the "root" object. |
| */ |
| protected Resolver resolver; |
| |
| @Override |
| protected void visit(Expression expression) { |
| resolver = queryContext.getResolver(expression); |
| } |
| |
| @Override |
| public void visit(SimpleSelectStatement expression) { |
| resolver = new FromSubqueryResolver( |
| DeclarationResolver.this, |
| DeclarationResolver.this.queryContext, |
| expression |
| ); |
| } |
| |
| @Override |
| public void visit(SubExpression expression) { |
| expression.getExpression().accept(this); |
| } |
| } |
| } |
