| /* |
| * 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 |
| // |
| package org.eclipse.persistence.jpa.jpql.tools.model; |
| |
| import java.util.ListIterator; |
| import org.eclipse.persistence.jpa.jpql.parser.OrderByItem.Ordering; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbsExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractConditionalClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractDoubleEncapsulatedExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractFromClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractIdentificationVariableDeclarationStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractModifyStatementStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractPathExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractRangeVariableDeclarationStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractSchemaNameStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractSelectStatementStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractSingleEncapsulatedExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AbstractTripleEncapsulatedExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AdditionExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AggregateFunctionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AllOrAnyExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AndExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ArithmeticFactorStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.AvgFunctionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.BadExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.BetweenExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.CaseExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.CoalesceExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.CollectionMemberDeclarationStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.CollectionMemberExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.CollectionValuedPathExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ComparisonExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.CompoundExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ConcatExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ConstructorExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.CountFunctionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.DateTimeStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.DeleteClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.DeleteStatementStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.DerivedPathIdentificationVariableDeclarationStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.DerivedPathVariableDeclarationStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.DivisionExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.EmptyCollectionComparisonExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.EncapsulatedIdentificationVariableExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.EntityTypeLiteralStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.EntryExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.EnumTypeStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ExistsExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.FromClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.FunctionExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.GroupByClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.HavingClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.IdentificationVariableDeclarationStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.IdentificationVariableStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.InExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.IndexExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.InputParameterStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.JPQLQueryStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.JoinStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.KeyExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.KeywordExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.LengthExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.LikeExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ListHolderStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.LocateExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.LowerExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.MaxFunctionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.MinFunctionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ModExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.MultiplicationExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.NotExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.NullComparisonExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.NullIfExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.NumericLiteralStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ObjectExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.OrExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.OrderByClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.OrderByItemStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.RangeVariableDeclarationStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ResultVariableStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SelectClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SelectStatementStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SimpleFromClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SimpleSelectClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SimpleSelectStatementStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SimpleStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SizeExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SqrtExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.StateFieldPathExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.StateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.StringLiteralStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SubExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SubstringExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SubtractionExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.SumFunctionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.TreatExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.TrimExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.TypeExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.UnknownExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.UpdateClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.UpdateItemStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.UpdateStatementStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.UpperExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.ValueExpressionStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.WhenClauseStateObject; |
| import org.eclipse.persistence.jpa.jpql.tools.model.query.WhereClauseStateObject; |
| import static org.eclipse.persistence.jpa.jpql.parser.Expression.*; |
| |
| /** |
| * The abstract definition of a {@link IJPQLQueryFormatter}, which converts an {@link StateObject} |
| * into its string representation that can be used as a real JPQL query. |
| * |
| * @version 2.5 |
| * @since 2.4 |
| * @author Pascal Filion |
| */ |
| public abstract class AbstractJPQLQueryFormatter extends BaseJPQLQueryFormatter { |
| |
| /** |
| * Creates a new <code>AbstractJPQLQueryFormatter</code>. |
| * |
| * @param style Determines how the JPQL identifiers are written out |
| * @exception NullPointerException The IdentifierStyle cannot be <code>null</code> |
| */ |
| protected AbstractJPQLQueryFormatter(IdentifierStyle style) { |
| super(style); |
| } |
| |
| protected String newLine() { |
| return SPACE; |
| } |
| |
| protected void toStringAggregateFunction(AggregateFunctionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| // <identifier> |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| |
| // '(' |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| // 'DISTINCT' |
| if (stateObject.hasDistinct()) { |
| writer.append(formatIdentifier(DISTINCT)); |
| writer.append(SPACE); |
| } |
| |
| // Encapsulated expression |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| } |
| |
| // ')' |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| protected void toStringChildren(ListHolderStateObject<? extends StateObject> stateObject, |
| boolean comma) { |
| |
| for (ListIterator<? extends StateObject> iter = stateObject.items().iterator(); iter.hasNext(); ) { |
| iter.next().accept(this); |
| if (iter.hasNext()) { |
| writer.append(comma ? COMMA_SPACE : SPACE); |
| } |
| } |
| } |
| |
| protected void toStringCompound(CompoundExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| if (stateObject.hasLeft()) { |
| stateObject.getLeft().accept(this); |
| writer.append(SPACE); |
| } |
| |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| |
| if (stateObject.hasRight()) { |
| writer.append(SPACE); |
| stateObject.getRight().accept(this); |
| } |
| } |
| } |
| |
| protected void toStringConditional(AbstractConditionalClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| |
| if (stateObject.hasConditional()) { |
| writer.append(SPACE); |
| stateObject.getConditional().accept(this); |
| } |
| } |
| } |
| |
| protected void toStringDoubleEncapsulated(AbstractDoubleEncapsulatedExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| if (stateObject.hasFirst()) { |
| stateObject.getFirst().accept(this); |
| } |
| |
| writer.append(COMMA); |
| |
| if (stateObject.hasSecond()) { |
| writer.append(SPACE); |
| stateObject.getSecond().accept(this); |
| } |
| |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| protected void toStringEncapsulatedIdentificationVariable(EncapsulatedIdentificationVariableExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| if (stateObject.hasIdentificationVariable()) { |
| writer.append(stateObject.getIdentificationVariable()); |
| } |
| |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| protected void toStringFromClause(AbstractFromClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(FROM)); |
| |
| if (stateObject.hasItems()) { |
| writer.append(SPACE); |
| toStringChildren(stateObject, true); |
| } |
| } |
| } |
| |
| protected void toStringIdentificationVariableDeclaration(AbstractIdentificationVariableDeclarationStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| stateObject.getRangeVariableDeclaration().accept(this); |
| |
| if (stateObject.hasItems()) { |
| writer.append(SPACE); |
| toStringChildren(stateObject, false); |
| } |
| } |
| } |
| |
| protected void toStringModifyStatement(AbstractModifyStatementStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| stateObject.getModifyClause().accept(this); |
| |
| if (stateObject.hasWhereClause()) { |
| writer.append(SPACE); |
| stateObject.getWhereClause().accept(this); |
| } |
| } |
| } |
| |
| protected void toStringPathExpression(AbstractPathExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| stateObject.toString(writer); |
| } |
| } |
| |
| protected void toStringRangeVariableDeclaration(AbstractRangeVariableDeclarationStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| // Root object |
| stateObject.getRootStateObject().accept(this); |
| |
| // 'AS' |
| if (stateObject.hasAs()) { |
| writer.append(SPACE); |
| writer.append(formatIdentifier(AS)); |
| } |
| |
| // Identification variable |
| if (stateObject.hasIdentificationVariable() && |
| !stateObject.isIdentificationVariableVirtual()) { |
| |
| writer.append(SPACE); |
| writer.append(stateObject.getIdentificationVariable()); |
| } |
| } |
| } |
| |
| protected void toStringSelectStatement(AbstractSelectStatementStateObject stateObject, |
| boolean useNewLine) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| stateObject.getSelectClause().accept(this); |
| writer.append(useNewLine ? newLine() : SPACE); |
| stateObject.getFromClause().accept(this); |
| |
| if (stateObject.hasWhereClause()) { |
| writer.append(useNewLine ? newLine() : SPACE); |
| stateObject.getWhereClause().accept(this); |
| } |
| |
| if (stateObject.hasGroupByClause()) { |
| writer.append(useNewLine ? newLine() : SPACE); |
| stateObject.getGroupByClause().accept(this); |
| } |
| |
| if (stateObject.hasHavingClause()) { |
| writer.append(useNewLine ? newLine() : SPACE); |
| stateObject.getHavingClause().accept(this); |
| } |
| } |
| } |
| |
| protected void toStringSimpleStateObject(SimpleStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else if (stateObject.hasText()) { |
| writer.append(stateObject.getText()); |
| } |
| } |
| |
| protected void toStringSingleEncapsulated(AbstractSingleEncapsulatedExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| } |
| |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| protected void toStringTripleEncapsulated(AbstractTripleEncapsulatedExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| if (stateObject.hasFirst()) { |
| stateObject.getFirst().accept(this); |
| } |
| |
| if (stateObject.hasSecond()) { |
| writer.append(COMMA); |
| writer.append(SPACE); |
| stateObject.getSecond().accept(this); |
| } |
| |
| if (stateObject.hasThird()) { |
| writer.append(COMMA); |
| writer.append(SPACE); |
| stateObject.getThird().accept(this); |
| } |
| |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(AbsExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(AbstractSchemaNameStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(AdditionExpressionStateObject stateObject) { |
| toStringCompound(stateObject); |
| } |
| |
| @Override |
| public void visit(AllOrAnyExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(AndExpressionStateObject stateObject) { |
| toStringCompound(stateObject); |
| } |
| |
| @Override |
| public void visit(ArithmeticFactorStateObject stateObject) { |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(stateObject.getArithmeticSign()); |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(AvgFunctionStateObject stateObject) { |
| toStringAggregateFunction(stateObject); |
| } |
| |
| @Override |
| public void visit(BadExpressionStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(BetweenExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| writer.append(SPACE); |
| } |
| |
| if (stateObject.hasNot()) { |
| writer.append(formatIdentifier(NOT_BETWEEN)); |
| } |
| else { |
| writer.append(formatIdentifier(BETWEEN)); |
| } |
| |
| if (stateObject.hasLowerBound()) { |
| writer.append(SPACE); |
| stateObject.getLowerBound().accept(this); |
| } |
| |
| writer.append(SPACE); |
| writer.append(formatIdentifier(AND)); |
| |
| if (stateObject.hasUpperBound()) { |
| writer.append(SPACE); |
| stateObject.getUpperBound().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(CaseExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(CASE)); |
| writer.append(SPACE); |
| |
| if (stateObject.hasCaseOperand()) { |
| stateObject.getCaseOperand().accept(this); |
| writer.append(SPACE); |
| } |
| |
| if (stateObject.hasItems()) { |
| toStringChildren(stateObject, false); |
| writer.append(SPACE); |
| } |
| |
| writer.append(formatIdentifier(ELSE)); |
| writer.append(SPACE); |
| |
| if (stateObject.hasElse()) { |
| stateObject.getElse().accept(this); |
| writer.append(SPACE); |
| } |
| |
| writer.append(formatIdentifier(END)); |
| } |
| } |
| |
| @Override |
| public void visit(CoalesceExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(COALESCE)); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| for (ListIterator<? extends StateObject> iter = stateObject.items().iterator(); iter.hasNext(); ) { |
| |
| iter.next().accept(this); |
| |
| if (iter.hasNext()) { |
| writer.append(COMMA_SPACE); |
| } |
| } |
| |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(CollectionMemberDeclarationStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(IN)); |
| |
| if (!stateObject.isDerived()) { |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| } |
| else { |
| writer.append(SPACE); |
| } |
| |
| stateObject.getCollectionValuedPath().accept(this); |
| |
| if (!stateObject.isDerived()) { |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| |
| if (stateObject.hasAs()) { |
| writer.append(SPACE); |
| writer.append(formatIdentifier(AS)); |
| } |
| |
| if (stateObject.hasIdentificationVariable()) { |
| writer.append(SPACE); |
| stateObject.getIdentificationVariable().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(CollectionMemberExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| if (stateObject.hasEntityStateObject()) { |
| stateObject.getEntityStateObject().accept(this); |
| writer.append(SPACE); |
| } |
| |
| if (stateObject.hasNot() && stateObject.hasOf()) { |
| writer.append(formatIdentifier(NOT_MEMBER_OF)); |
| } |
| else if (stateObject.hasNot()) { |
| writer.append(formatIdentifier(NOT_MEMBER)); |
| } |
| else if (stateObject.hasOf()) { |
| writer.append(formatIdentifier(MEMBER_OF)); |
| } |
| else { |
| writer.append(formatIdentifier(MEMBER)); |
| } |
| |
| writer.append(SPACE); |
| stateObject.getCollectionValuedPath().accept(this); |
| } |
| } |
| |
| @Override |
| public void visit(CollectionValuedPathExpressionStateObject stateObject) { |
| toStringPathExpression(stateObject); |
| } |
| |
| @Override |
| public void visit(ComparisonExpressionStateObject stateObject) { |
| toStringCompound(stateObject); |
| } |
| |
| @Override |
| public void visit(ConcatExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(CONCAT)); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| toStringChildren(stateObject, true); |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(ConstructorExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| // 'NEW' |
| writer.append(formatIdentifier(NEW)); |
| writer.append(SPACE); |
| |
| // Class name |
| writer.append(stateObject.getClassName()); |
| |
| // '(' |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| // Constructor parameters |
| toStringChildren(stateObject, true); |
| |
| // ')' |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(CountFunctionStateObject stateObject) { |
| toStringAggregateFunction(stateObject); |
| } |
| |
| @Override |
| public void visit(DateTimeStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else if (stateObject.hasText()) { |
| writer.append(formatIdentifier(stateObject.getText())); |
| } |
| } |
| |
| @Override |
| public void visit(DeleteClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(DELETE_FROM)); |
| writer.append(SPACE); |
| stateObject.getRangeVariableDeclaration().accept(this); |
| } |
| } |
| |
| @Override |
| public void visit(DeleteStatementStateObject stateObject) { |
| toStringModifyStatement(stateObject); |
| } |
| |
| @Override |
| public void visit(DerivedPathIdentificationVariableDeclarationStateObject stateObject) { |
| toStringIdentificationVariableDeclaration(stateObject); |
| } |
| |
| @Override |
| public void visit(DerivedPathVariableDeclarationStateObject stateObject) { |
| toStringRangeVariableDeclaration(stateObject); |
| } |
| |
| @Override |
| public void visit(DivisionExpressionStateObject stateObject) { |
| toStringCompound(stateObject); |
| } |
| |
| @Override |
| public void visit(EmptyCollectionComparisonExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| stateObject.getStateObject().accept(this); |
| writer.append(SPACE); |
| writer.append(formatIdentifier(stateObject.hasNot() ? IS_NOT_EMPTY : IS_EMPTY)); |
| } |
| } |
| |
| @Override |
| public void visit(EntityTypeLiteralStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(EntryExpressionStateObject stateObject) { |
| toStringEncapsulatedIdentificationVariable(stateObject); |
| } |
| |
| @Override |
| public void visit(EnumTypeStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(ExistsExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| // 'NOT' |
| if (stateObject.hasNot()) { |
| writer.append(formatIdentifier(NOT)); |
| writer.append(SPACE); |
| } |
| |
| // 'EXISTS' |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| |
| // '(' |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| // Subquery |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| } |
| |
| // ')' |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(FromClauseStateObject stateObject) { |
| toStringFromClause(stateObject); |
| } |
| |
| @Override |
| public void visit(FunctionExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| stateObject.getDecorator().accept(this); |
| } |
| else { |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| if (stateObject.hasFunctionName()) { |
| writer.append(stateObject.getQuotedFunctionName()); |
| |
| if (stateObject.hasItems()) { |
| writer.append(COMMA_SPACE); |
| } |
| } |
| |
| toStringChildren(stateObject, true); |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(GroupByClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(GROUP_BY)); |
| |
| if (stateObject.hasItems()) { |
| writer.append(SPACE); |
| toStringChildren(stateObject, true); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(HavingClauseStateObject stateObject) { |
| toStringConditional(stateObject); |
| } |
| |
| @Override |
| public void visit(IdentificationVariableDeclarationStateObject stateObject) { |
| toStringIdentificationVariableDeclaration(stateObject); |
| } |
| |
| @Override |
| public void visit(IdentificationVariableStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(IndexExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(INDEX)); |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| if (stateObject.hasIdentificationVariable()) { |
| writer.append(stateObject.getIdentificationVariable()); |
| } |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(InExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| // State object |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| writer.append(SPACE); |
| } |
| |
| // 'IN' |
| writer.append(formatIdentifier(stateObject.hasNot() ? NOT_IN : IN)); |
| |
| // Input parameter |
| if (stateObject.isSingleInputParameter()) { |
| writer.append(SPACE); |
| toStringChildren(stateObject, false); |
| } |
| // Encapsulated state object |
| else { |
| // '(' |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| // Encapsulated state objects |
| if (stateObject.hasItems()) { |
| toStringChildren(stateObject, true); |
| } |
| |
| // ')' |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(InputParameterStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(JoinStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| writer.append(formatIdentifier(stateObject.getJoinType())); |
| writer.append(SPACE); |
| stateObject.getJoinAssociationPathStateObject().accept(this); |
| |
| if (stateObject.hasAs()) { |
| writer.append(formatIdentifier(AS)); |
| } |
| |
| if (stateObject.hasIdentificationVariable()) { |
| writer.append(SPACE); |
| stateObject.getIdentificationVariableStateObject().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(JPQLQueryStateObject stateObject) { |
| toText(stateObject.getQueryStatement()); |
| } |
| |
| @Override |
| public void visit(KeyExpressionStateObject stateObject) { |
| toStringEncapsulatedIdentificationVariable(stateObject); |
| } |
| |
| @Override |
| public void visit(KeywordExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else if (stateObject.hasText()) { |
| writer.append(formatIdentifier(stateObject.getText())); |
| } |
| } |
| |
| @Override |
| public void visit(LengthExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(LikeExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| if (stateObject.hasStringStateObject()) { |
| stateObject.getStringStateObject().accept(this); |
| writer.append(SPACE); |
| } |
| |
| writer.append(formatIdentifier(stateObject.hasNot() ? NOT_LIKE : LIKE)); |
| |
| if (stateObject.hasPatternValue()) { |
| writer.append(SPACE); |
| stateObject.getPatternValue().accept(this); |
| } |
| |
| if (stateObject.hasEscapeCharacter()) { |
| writer.append(SPACE); |
| writer.append(formatIdentifier(ESCAPE)); |
| writer.append(SPACE); |
| writer.append(stateObject.getEscapeCharacter()); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(LocateExpressionStateObject stateObject) { |
| toStringTripleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(LowerExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(MaxFunctionStateObject stateObject) { |
| toStringAggregateFunction(stateObject); |
| } |
| |
| @Override |
| public void visit(MinFunctionStateObject stateObject) { |
| toStringAggregateFunction(stateObject); |
| } |
| |
| @Override |
| public void visit(ModExpressionStateObject stateObject) { |
| toStringDoubleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(MultiplicationExpressionStateObject stateObject) { |
| toStringCompound(stateObject); |
| } |
| |
| @Override |
| public void visit(NotExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(NOT)); |
| |
| if (stateObject.hasStateObject()) { |
| writer.append(SPACE); |
| stateObject.getStateObject().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(NullComparisonExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| writer.append(SPACE); |
| } |
| |
| writer.append(formatIdentifier(stateObject.hasNot() ? IS_NOT_NULL : IS_NULL)); |
| } |
| } |
| |
| @Override |
| public void visit(NullIfExpressionStateObject stateObject) { |
| toStringDoubleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(NumericLiteralStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(ObjectExpressionStateObject stateObject) { |
| toStringEncapsulatedIdentificationVariable(stateObject); |
| } |
| |
| @Override |
| public void visit(OrderByClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(ORDER_BY)); |
| |
| if (stateObject.hasItems()) { |
| writer.append(SPACE); |
| toStringChildren(stateObject, true); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(OrderByItemStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| } |
| |
| if (stateObject.getOrdering() != Ordering.DEFAULT) { |
| writer.append(SPACE); |
| writer.append(formatIdentifier(stateObject.getOrdering().name())); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(OrExpressionStateObject stateObject) { |
| toStringCompound(stateObject); |
| } |
| |
| @Override |
| public void visit(RangeVariableDeclarationStateObject stateObject) { |
| toStringRangeVariableDeclaration(stateObject); |
| } |
| |
| @Override |
| public void visit(ResultVariableStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| // Select item |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| } |
| |
| // 'AS' |
| if (stateObject.hasAs()) { |
| writer.append(SPACE); |
| writer.append(formatIdentifier(AS)); |
| } |
| |
| // Result variable |
| if (stateObject.hasResultVariable()) { |
| writer.append(SPACE); |
| writer.append(stateObject.getResultVariable()); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(SelectClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(SELECT)); |
| |
| if (stateObject.hasDistinct()) { |
| writer.append(SPACE); |
| writer.append(formatIdentifier(DISTINCT)); |
| } |
| |
| if (stateObject.hasItems()) { |
| writer.append(SPACE); |
| toStringChildren(stateObject, true); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(SelectStatementStateObject stateObject) { |
| |
| toStringSelectStatement(stateObject, true); |
| |
| if (stateObject.hasOrderByClause()) { |
| writer.append(newLine()); |
| stateObject.getOrderByClause().accept(this); |
| } |
| } |
| |
| @Override |
| public void visit(SimpleFromClauseStateObject stateObject) { |
| toStringFromClause(stateObject); |
| } |
| |
| @Override |
| public void visit(SimpleSelectClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(SELECT)); |
| |
| if (stateObject.hasDistinct()) { |
| writer.append(SPACE); |
| writer.append(formatIdentifier(DISTINCT)); |
| } |
| |
| if (stateObject.hasSelectItem()) { |
| writer.append(SPACE); |
| stateObject.getSelectItem().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(SimpleSelectStatementStateObject stateObject) { |
| toStringSelectStatement(stateObject, false); |
| } |
| |
| @Override |
| public void visit(SizeExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(SqrtExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(StateFieldPathExpressionStateObject stateObject) { |
| toStringPathExpression(stateObject); |
| } |
| |
| @Override |
| public void visit(StringLiteralStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(SubExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(SubstringExpressionStateObject stateObject) { |
| toStringTripleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(SubtractionExpressionStateObject stateObject) { |
| toStringCompound(stateObject); |
| } |
| |
| @Override |
| public void visit(SumFunctionStateObject stateObject) { |
| toStringAggregateFunction(stateObject); |
| } |
| |
| @Override |
| public void visit(TreatExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| stateObject.getDecorator().accept(this); |
| } |
| else { |
| // TREAT |
| writer.append(formatIdentifier(TREAT)); |
| |
| // ( |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| // Collection-valued path expression |
| stateObject.getJoinAssociationPathStateObject().toText(writer); |
| |
| writer.append(SPACE); |
| |
| // AS |
| if (stateObject.hasAs()) { |
| writer.append(formatIdentifier(AS)); |
| writer.append(SPACE); |
| } |
| |
| // Entity type name |
| writer.append(stateObject.getEntityTypeName()); |
| |
| // ) |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(TrimExpressionStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| // 'TRIM' |
| writer.append(formatIdentifier(stateObject.getIdentifier())); |
| |
| // '(' |
| writer.append(formatIdentifier(LEFT_PARENTHESIS)); |
| |
| // Trim specification |
| if (stateObject.hasSpecification()) { |
| writer.append(formatIdentifier(stateObject.getSpecification().name())); |
| writer.append(SPACE); |
| } |
| |
| // Trim character |
| if (stateObject.hasTrimCharacter()) { |
| stateObject.getTrimCharacter().accept(this); |
| writer.append(SPACE); |
| } |
| |
| // 'FROM' |
| if (stateObject.hasSpecification() || |
| stateObject.hasTrimCharacter()) { |
| |
| writer.append(formatIdentifier(FROM)); |
| writer.append(SPACE); |
| } |
| |
| // Encapsulated expression |
| if (stateObject.hasStateObject()) { |
| stateObject.getStateObject().accept(this); |
| } |
| |
| // ')' |
| writer.append(formatIdentifier(RIGHT_PARENTHESIS)); |
| } |
| } |
| |
| @Override |
| public void visit(TypeExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(UnknownExpressionStateObject stateObject) { |
| toStringSimpleStateObject(stateObject); |
| } |
| |
| @Override |
| public void visit(UpdateClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(UPDATE)); |
| writer.append(SPACE); |
| stateObject.getRangeVariableDeclaration().accept(this); |
| writer.append(SPACE); |
| writer.append(formatIdentifier(SET)); |
| |
| if (stateObject.hasItems()) { |
| writer.append(SPACE); |
| toStringChildren(stateObject, true); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(UpdateItemStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| stateObject.getStateFieldPath().accept(this); |
| |
| writer.append(SPACE); |
| writer.append(formatIdentifier(EQUAL)); |
| |
| if (stateObject.hasNewValue()) { |
| writer.append(SPACE); |
| stateObject.getNewValue().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(UpdateStatementStateObject stateObject) { |
| toStringModifyStatement(stateObject); |
| } |
| |
| @Override |
| public void visit(UpperExpressionStateObject stateObject) { |
| toStringSingleEncapsulated(stateObject); |
| } |
| |
| @Override |
| public void visit(ValueExpressionStateObject stateObject) { |
| toStringEncapsulatedIdentificationVariable(stateObject); |
| } |
| |
| @Override |
| public void visit(WhenClauseStateObject stateObject) { |
| |
| if (stateObject.isDecorated()) { |
| toText(stateObject); |
| } |
| else { |
| |
| writer.append(formatIdentifier(WHEN)); |
| |
| if (stateObject.hasConditional()) { |
| writer.append(SPACE); |
| stateObject.getConditional().accept(this); |
| } |
| |
| writer.append(SPACE); |
| writer.append(formatIdentifier(THEN)); |
| |
| if (stateObject.hasThen()) { |
| writer.append(SPACE); |
| stateObject.getThen().accept(this); |
| } |
| } |
| } |
| |
| @Override |
| public void visit(WhereClauseStateObject stateObject) { |
| toStringConditional(stateObject); |
| } |
| } |
