jpa/org.eclipse.persistence.jpa.jpql/src/main/java/org/eclipse/persistence/jpa/jpql/parser/UpdateClause.java - eclipselink - Git at Google

 /*
  * 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.parser;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import org.eclipse.persistence.jpa.jpql.ExpressionTools;
 import org.eclipse.persistence.jpa.jpql.WordParser;

 /**
  * This is the update clause of the update statement.
  * <p>
  * An <b>UPDATE</b> statement provides bulk operations over sets of entities of a single entity
  * class (together with its subclasses, if any). Only one entity abstract schema type may be
  * specified in the <b>UPDATE</b> clause.
  *
  * <div><b>BNF:</b> <code>update_clause ::= UPDATE abstract_schema_name [[AS] identification_variable] SET update_item {, update_item}*</code></div>
  *
  * @see UpdateStatement
  * @see UpdateItem
  *
  * @version 2.5
  * @since 2.3
  * @author Pascal Filion
  */
 public final class UpdateClause extends AbstractExpression {

     /**
      * Determines whether a whitespace was parsed after the abstract schema name declaration.
      */
     private boolean hasSpaceAfterRangeVariableDeclaration;

     /**
      * Determines whether a whitespace was parsed after <b>SET</b>.
      */
     private boolean hasSpaceAfterSet;

     /**
      * Determines whether a whitespace was parsed after <b>UPDATE</b>.
      */
     private boolean hasSpaceAfterUpdate;

     /**
      * The {@link Expression} representing the range variable declaration.
      */
     private AbstractExpression rangeVariableDeclaration;

     /**
      * The actual <b>SET</b> identifier found in the string representation of the JPQL query.
      */
     private String setIdentifier;

     /**
      * The actual <b>UPDATE</b> identifier found in the string representation of the JPQL query.
      */
     private String updateIdentifier;

     /**
      * The expression containing the update items.
      */
     private AbstractExpression updateItems;

     /**
      * Creates a new <code>UpdateClause</code>.
      *
      * @param parent The parent of this expression
      */
     public UpdateClause(AbstractExpression parent) {
         super(parent, UPDATE);
     }

     @Override
     public void accept(ExpressionVisitor visitor) {
         visitor.visit(this);
     }

     @Override
     public void acceptChildren(ExpressionVisitor visitor) {
         getRangeVariableDeclaration().accept(visitor);
         getUpdateItems().accept(visitor);
     }

     @Override
     protected void addChildrenTo(Collection<Expression> children) {
         children.add(getRangeVariableDeclaration());
         children.add(getUpdateItems());
     }

     @Override
     protected void addOrderedChildrenTo(List<Expression> children) {

         // 'UPDATE'
         children.add(buildStringExpression(UPDATE));

         if (hasSpaceAfterUpdate) {
             children.add(buildStringExpression(SPACE));
         }

         // Range variable declaration
         if (rangeVariableDeclaration != null) {
             children.add(rangeVariableDeclaration);
         }

         if (hasSpaceAfterRangeVariableDeclaration) {
             children.add(buildStringExpression(SPACE));
         }

         // 'SET'
         if (setIdentifier != null) {
             children.add(buildStringExpression(SET));
         }

         if (hasSpaceAfterSet) {
             children.add(buildStringExpression(SPACE));
         }

         // Update items
         if (updateItems != null) {
             children.add(updateItems);
         }
     }

     /**
      * Creates a new {@link CollectionExpression} that will wrap the single update item.
      *
      * @return The single update item represented by a temporary collection
      */
     public CollectionExpression buildCollectionExpression() {

         List<AbstractExpression> children = new ArrayList<>(1);
         children.add((AbstractExpression) getUpdateItems());

         List<Boolean> commas = new ArrayList<>(1);
         commas.add(Boolean.FALSE);

         List<Boolean> spaces = new ArrayList<>(1);
         spaces.add(Boolean.FALSE);

         return new CollectionExpression(this, children, commas, spaces, true);
     }

     @Override
     public JPQLQueryBNF findQueryBNF(Expression expression) {

         if ((rangeVariableDeclaration != null) && rangeVariableDeclaration.isAncestor(expression)) {
             return getQueryBNF(RangeVariableDeclarationBNF.ID);
         }

         if ((updateItems != null) && updateItems.isAncestor(expression)) {
             return getQueryBNF(InternalUpdateClauseBNF.ID);
         }

         return super.findQueryBNF(expression);
     }

     /**
      * Returns the actual <b>SET</b> found in the string representation of the JPQL query, which has
      * the actual case that was used.
      *
      * @return The <b>SET</b> identifier that was actually parsed, or an empty string if it was not parsed
      */
     public String getActualSetIdentifier() {
         return (setIdentifier != null) ? setIdentifier : ExpressionTools.EMPTY_STRING;
     }

     /**
      * Returns the actual <b>UPDATE</b> found in the string representation of the JPQL query, which
      * has the actual case that was used.
      *
      * @return The <b>UPDATE</b> identifier that was actually parsed
      */
     public String getActualUpdateIdentifier() {
         return updateIdentifier;
     }

     @Override
     public JPQLQueryBNF getQueryBNF() {
         return getQueryBNF(UpdateClauseBNF.ID);
     }

     /**
      * Returns the {@link Expression} representing the range variable declaration.
      *
      * @return The expression that was parsed representing the range variable declaration
      */
     public Expression getRangeVariableDeclaration() {
         if (rangeVariableDeclaration == null) {
             rangeVariableDeclaration = buildNullExpression();
         }
         return rangeVariableDeclaration;
     }

     /**
      * Returns the {@link Expression} representing the single update item or the collection of update items.
      *
      * @return The expression that was parsed representing the single or multiple update items
      */
     public Expression getUpdateItems() {
         if (updateItems == null) {
             updateItems = buildNullExpression();
         }
         return updateItems;
     }

     /**
      * Determines whether the range variable declaration was parsed.
      *
      * @return <code>true</code> if the range variable declaration was parsed; <code>false</code> otherwise
      */
     public boolean hasRangeVariableDeclaration() {
         return rangeVariableDeclaration != null &&
               !rangeVariableDeclaration.isNull();
     }

     /**
      * Determines whether <b>SET</b> was parsed or not.
      *
      * @return <code>true</code> if <b>SET</b> was part of the query; <code>false</code> otherwise
      */
     public boolean hasSet() {
         return setIdentifier != null;
     }

     /**
      * Determines whether a whitespace was found after the abstract schema name declaration.
      *
      * @return <code>true</code> if there was a whitespace after the abstract schema name declaration;
      * <code>false</code> otherwise
      */
     public boolean hasSpaceAfterRangeVariableDeclaration() {
         return hasSpaceAfterRangeVariableDeclaration;
     }

     /**
      * Determines whether a whitespace was found after <b>SET</b>.
      *
      * @return <code>true</code> if there was a whitespace after <b>SET</b>; <code>false</code> otherwise
      */
     public boolean hasSpaceAfterSet() {
         return hasSpaceAfterSet;
     }

     /**
      * Determines whether a whitespace was found after the identifier <b>UPDATE</b>.
      *
      * @return <code>true</code> if there was a whitespace after the identifier <b>UPDATE</b>;
      * <code>false</code> otherwise
      */
     public boolean hasSpaceAfterUpdate() {
         return hasSpaceAfterUpdate;
     }

     /**
      * Determines whether the update items section of the query was parsed.
      *
      * @return <code>true</code> if something was parsed after <b>SET</b> even if it was a malformed
      * expression; <code>false</code> if nothing was parsed
      */
     public boolean hasUpdateItems() {
         return updateItems != null &&
               !updateItems.isNull();
     }

     @Override
     protected boolean isParsingComplete(WordParser wordParser, String word, Expression expression) {
         return word.equalsIgnoreCase(SET)   ||
                super.isParsingComplete(wordParser, word, expression);
     }

     @Override
     protected void parse(WordParser wordParser, boolean tolerant) {

         // Parse 'UPDATE'
         updateIdentifier = wordParser.moveForward(UPDATE);

         hasSpaceAfterUpdate = wordParser.skipLeadingWhitespace() > 0;

         // Parse the abstract schema name
         if (tolerant && !wordParser.startsWithIdentifier(SET)) {
             rangeVariableDeclaration = parse(
                 wordParser,
                 RangeVariableDeclarationBNF.ID,
                 tolerant
             );
         }
         else if (!tolerant) {
             rangeVariableDeclaration = new RangeVariableDeclaration(this);
             rangeVariableDeclaration.parse(wordParser, tolerant);
         }

         hasSpaceAfterRangeVariableDeclaration = wordParser.skipLeadingWhitespace() > 0;

         // Parse 'SET'
         if (!tolerant || wordParser.startsWithIdentifier(SET)) {
             setIdentifier = wordParser.moveForward(SET);
             hasSpaceAfterSet = wordParser.skipLeadingWhitespace() > 0;
         }

         // Parse update items
         updateItems = parse(wordParser, InternalUpdateClauseBNF.ID, tolerant);
     }

     @Override
     protected void toParsedText(StringBuilder writer, boolean actual) {

         // 'UPDATE'
         writer.append(actual ? updateIdentifier : UPDATE);

         if (hasSpaceAfterUpdate) {
             writer.append(SPACE);
         }

         // Range variable declaration
         if (rangeVariableDeclaration != null) {
             rangeVariableDeclaration.toParsedText(writer, actual);
         }

         if (hasSpaceAfterRangeVariableDeclaration) {
             writer.append(SPACE);
         }

         // 'SET'
         if (setIdentifier != null) {
             writer.append(actual ? setIdentifier : SET);
         }

         if (hasSpaceAfterSet) {
             writer.append(SPACE);
         }

         // Update items
         if (updateItems != null) {
             updateItems.toParsedText(writer, actual);
         }
     }
 }
	/*
	* 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.parser;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import org.eclipse.persistence.jpa.jpql.ExpressionTools;
	import org.eclipse.persistence.jpa.jpql.WordParser;

	/**
	* This is the update clause of the update statement.
	* <p>
	* An <b>UPDATE</b> statement provides bulk operations over sets of entities of a single entity
	* class (together with its subclasses, if any). Only one entity abstract schema type may be
	* specified in the <b>UPDATE</b> clause.
	*
	* <div><b>BNF:</b> <code>update_clause ::= UPDATE abstract_schema_name [[AS] identification_variable] SET update_item {, update_item}*</code></div>
	*
	* @see UpdateStatement
	* @see UpdateItem
	*
	* @version 2.5
	* @since 2.3
	* @author Pascal Filion
	*/
	public final class UpdateClause extends AbstractExpression {

	/**
	* Determines whether a whitespace was parsed after the abstract schema name declaration.
	*/
	private boolean hasSpaceAfterRangeVariableDeclaration;

	/**
	* Determines whether a whitespace was parsed after <b>SET</b>.
	*/
	private boolean hasSpaceAfterSet;

	/**
	* Determines whether a whitespace was parsed after <b>UPDATE</b>.
	*/
	private boolean hasSpaceAfterUpdate;

	/**
	* The {@link Expression} representing the range variable declaration.
	*/
	private AbstractExpression rangeVariableDeclaration;

	/**
	* The actual <b>SET</b> identifier found in the string representation of the JPQL query.
	*/
	private String setIdentifier;

	/**
	* The actual <b>UPDATE</b> identifier found in the string representation of the JPQL query.
	*/
	private String updateIdentifier;

	/**
	* The expression containing the update items.
	*/
	private AbstractExpression updateItems;

	/**
	* Creates a new <code>UpdateClause</code>.
	*
	* @param parent The parent of this expression
	*/
	public UpdateClause(AbstractExpression parent) {
	super(parent, UPDATE);
	}

	@Override
	public void accept(ExpressionVisitor visitor) {
	visitor.visit(this);
	}

	@Override
	public void acceptChildren(ExpressionVisitor visitor) {
	getRangeVariableDeclaration().accept(visitor);
	getUpdateItems().accept(visitor);
	}

	@Override
	protected void addChildrenTo(Collection<Expression> children) {
	children.add(getRangeVariableDeclaration());
	children.add(getUpdateItems());
	}

	@Override
	protected void addOrderedChildrenTo(List<Expression> children) {

	// 'UPDATE'
	children.add(buildStringExpression(UPDATE));

	if (hasSpaceAfterUpdate) {
	children.add(buildStringExpression(SPACE));
	}

	// Range variable declaration
	if (rangeVariableDeclaration != null) {
	children.add(rangeVariableDeclaration);
	}

	if (hasSpaceAfterRangeVariableDeclaration) {
	children.add(buildStringExpression(SPACE));
	}

	// 'SET'
	if (setIdentifier != null) {
	children.add(buildStringExpression(SET));
	}

	if (hasSpaceAfterSet) {
	children.add(buildStringExpression(SPACE));
	}

	// Update items
	if (updateItems != null) {
	children.add(updateItems);
	}
	}

	/**
	* Creates a new {@link CollectionExpression} that will wrap the single update item.
	*
	* @return The single update item represented by a temporary collection
	*/
	public CollectionExpression buildCollectionExpression() {

	List<AbstractExpression> children = new ArrayList<>(1);
	children.add((AbstractExpression) getUpdateItems());

	List<Boolean> commas = new ArrayList<>(1);
	commas.add(Boolean.FALSE);

	List<Boolean> spaces = new ArrayList<>(1);
	spaces.add(Boolean.FALSE);

	return new CollectionExpression(this, children, commas, spaces, true);
	}

	@Override
	public JPQLQueryBNF findQueryBNF(Expression expression) {

	if ((rangeVariableDeclaration != null) && rangeVariableDeclaration.isAncestor(expression)) {
	return getQueryBNF(RangeVariableDeclarationBNF.ID);
	}

	if ((updateItems != null) && updateItems.isAncestor(expression)) {
	return getQueryBNF(InternalUpdateClauseBNF.ID);
	}

	return super.findQueryBNF(expression);
	}

	/**
	* Returns the actual <b>SET</b> found in the string representation of the JPQL query, which has
	* the actual case that was used.
	*
	* @return The <b>SET</b> identifier that was actually parsed, or an empty string if it was not parsed
	*/
	public String getActualSetIdentifier() {
	return (setIdentifier != null) ? setIdentifier : ExpressionTools.EMPTY_STRING;
	}

	/**
	* Returns the actual <b>UPDATE</b> found in the string representation of the JPQL query, which
	* has the actual case that was used.
	*
	* @return The <b>UPDATE</b> identifier that was actually parsed
	*/
	public String getActualUpdateIdentifier() {
	return updateIdentifier;
	}

	@Override
	public JPQLQueryBNF getQueryBNF() {
	return getQueryBNF(UpdateClauseBNF.ID);
	}

	/**
	* Returns the {@link Expression} representing the range variable declaration.
	*
	* @return The expression that was parsed representing the range variable declaration
	*/
	public Expression getRangeVariableDeclaration() {
	if (rangeVariableDeclaration == null) {
	rangeVariableDeclaration = buildNullExpression();
	}
	return rangeVariableDeclaration;
	}

	/**
	* Returns the {@link Expression} representing the single update item or the collection of update items.
	*
	* @return The expression that was parsed representing the single or multiple update items
	*/
	public Expression getUpdateItems() {
	if (updateItems == null) {
	updateItems = buildNullExpression();
	}
	return updateItems;
	}

	/**
	* Determines whether the range variable declaration was parsed.
	*
	* @return <code>true</code> if the range variable declaration was parsed; <code>false</code> otherwise
	*/
	public boolean hasRangeVariableDeclaration() {
	return rangeVariableDeclaration != null &&
	!rangeVariableDeclaration.isNull();
	}

	/**
	* Determines whether <b>SET</b> was parsed or not.
	*
	* @return <code>true</code> if <b>SET</b> was part of the query; <code>false</code> otherwise
	*/
	public boolean hasSet() {
	return setIdentifier != null;
	}

	/**
	* Determines whether a whitespace was found after the abstract schema name declaration.
	*
	* @return <code>true</code> if there was a whitespace after the abstract schema name declaration;
	* <code>false</code> otherwise
	*/
	public boolean hasSpaceAfterRangeVariableDeclaration() {
	return hasSpaceAfterRangeVariableDeclaration;
	}

	/**
	* Determines whether a whitespace was found after <b>SET</b>.
	*
	* @return <code>true</code> if there was a whitespace after <b>SET</b>; <code>false</code> otherwise
	*/
	public boolean hasSpaceAfterSet() {
	return hasSpaceAfterSet;
	}

	/**
	* Determines whether a whitespace was found after the identifier <b>UPDATE</b>.
	*
	* @return <code>true</code> if there was a whitespace after the identifier <b>UPDATE</b>;
	* <code>false</code> otherwise
	*/
	public boolean hasSpaceAfterUpdate() {
	return hasSpaceAfterUpdate;
	}

	/**
	* Determines whether the update items section of the query was parsed.
	*
	* @return <code>true</code> if something was parsed after <b>SET</b> even if it was a malformed
	* expression; <code>false</code> if nothing was parsed
	*/
	public boolean hasUpdateItems() {
	return updateItems != null &&
	!updateItems.isNull();
	}

	@Override
	protected boolean isParsingComplete(WordParser wordParser, String word, Expression expression) {
	return word.equalsIgnoreCase(SET) \|\|
	super.isParsingComplete(wordParser, word, expression);
	}

	@Override
	protected void parse(WordParser wordParser, boolean tolerant) {

	// Parse 'UPDATE'
	updateIdentifier = wordParser.moveForward(UPDATE);

	hasSpaceAfterUpdate = wordParser.skipLeadingWhitespace() > 0;

	// Parse the abstract schema name
	if (tolerant && !wordParser.startsWithIdentifier(SET)) {
	rangeVariableDeclaration = parse(
	wordParser,
	RangeVariableDeclarationBNF.ID,
	tolerant
	);
	}
	else if (!tolerant) {
	rangeVariableDeclaration = new RangeVariableDeclaration(this);
	rangeVariableDeclaration.parse(wordParser, tolerant);
	}

	hasSpaceAfterRangeVariableDeclaration = wordParser.skipLeadingWhitespace() > 0;

	// Parse 'SET'
	if (!tolerant \|\| wordParser.startsWithIdentifier(SET)) {
	setIdentifier = wordParser.moveForward(SET);
	hasSpaceAfterSet = wordParser.skipLeadingWhitespace() > 0;
	}

	// Parse update items
	updateItems = parse(wordParser, InternalUpdateClauseBNF.ID, tolerant);
	}

	@Override
	protected void toParsedText(StringBuilder writer, boolean actual) {

	// 'UPDATE'
	writer.append(actual ? updateIdentifier : UPDATE);

	if (hasSpaceAfterUpdate) {
	writer.append(SPACE);
	}

	// Range variable declaration
	if (rangeVariableDeclaration != null) {
	rangeVariableDeclaration.toParsedText(writer, actual);
	}

	if (hasSpaceAfterRangeVariableDeclaration) {
	writer.append(SPACE);
	}

	// 'SET'
	if (setIdentifier != null) {
	writer.append(actual ? setIdentifier : SET);
	}

	if (hasSpaceAfterSet) {
	writer.append(SPACE);
	}

	// Update items
	if (updateItems != null) {
	updateItems.toParsedText(writer, actual);
	}
	}
	}