Fix for JPQL queries where identifier clashes with function

jpa/eclipselink.jpa.testapps/jpa.test.persistence32/src/main/java/org/eclipse/persistence/testing/models/jpa/persistence32/Pokemon.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024 Contributors to the Eclipse Foundation. 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
@@ -55,6 +56,9 @@ public class Pokemon {
 
     private String name;
 
+    // to test queries where entity field clashes with a function name in QueryTest
+    private int length = 0;
+
     @ManyToOne
     @JoinColumn(name = "TRAINER_ID")
     private Trainer trainer;
@@ -129,6 +133,14 @@ public void setTrainer(Trainer trainer) {
         this.trainer = trainer;
     }
 
+    public int getLength() {
+        return length;
+    }
+
+    public void setLength(int length) {
+        this.length = length;
+    }
+
     @Override
     public boolean equals(Object obj) {
         if (obj == null || obj.getClass() != this.getClass()) {

jpa/eclipselink.jpa.testapps/jpa.test.persistence32/src/test/java/org/eclipse/persistence/testing/tests/jpa/persistence32/QueryTest.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024 Contributors to the Eclipse Foundation. 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
@@ -11,10 +12,15 @@
  */
 package org.eclipse.persistence.testing.tests.jpa.persistence32;
 
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
 import java.util.List;
 
 import jakarta.persistence.NoResultException;
 import jakarta.persistence.NonUniqueResultException;
+import java.util.stream.Stream;
 import junit.framework.Test;
 import org.eclipse.persistence.testing.models.jpa.persistence32.Pokemon;
 import org.junit.Assert;
@@ -34,6 +40,8 @@ public class QueryTest extends AbstractPokemon {
             new Pokemon(4, "Caterpie", List.of(TYPES[7]))
     };
 
+    static final long POKEMONS_COUNT = POKEMONS.length -1; // we ignore the first one with index 0
+
     public static Test suite() {
         return suite(
                 "QueryTest",
@@ -42,7 +50,12 @@ public static Test suite() {
                 new QueryTest("testGetSingleResultWithMultipleResults"),
                 new QueryTest("testGetSingleResultOrNullWithEmptyResult"),
                 new QueryTest("testGetSingleResultOrNullWithSingleResult"),
-                new QueryTest("testGetSingleResultOrNullWithMultipleResults")
+                new QueryTest("testGetSingleResultOrNullWithMultipleResults"),
+                new QueryTest("testUpdateQueryLengthInAssignmentAndExpression"),
+                new QueryTest("tesUpdateQueryWithThisVariable"),
+                new QueryTest("testSelectQueryLengthInAssignmentAndExpression"),
+                new QueryTest("testDeleteQueryLengthInExpressionOnLeft"),
+                new QueryTest("testDeleteQueryLengthInExpressionOnRight")
         );
     }
 
@@ -54,11 +67,12 @@ public QueryTest(String name) {
         setPuName(getPersistenceUnitName());
     }
 
-    // Initialize data
+    // Initialize data for each test
     @Override
-    protected void suiteSetUp() {
-        super.suiteSetUp();
+    public void setUp() {
+        super.setUp();
         emf.runInTransaction(em -> {
+            em.createQuery("DELETE FROM Pokemon").executeUpdate();
             for (int i = 1; i < POKEMONS.length; i++) {
                 em.persist(POKEMONS[i]);
             }
@@ -108,4 +122,49 @@ public void testGetSingleResultOrNullWithMultipleResults() {
                         "SELECT p FROM Pokemon p ", Pokemon.class).getSingleResultOrNull()));
     }
 
+    public void testUpdateQueryLengthInAssignmentAndExpression() {
+        testUpdateAllPokemons("UPDATE Pokemon SET length = length + 1");
+    }
+
+    public void tesUpdateQueryWithThisVariable() {
+        testUpdateAllPokemons("UPDATE Pokemon SET length = this.length + 1");
+    }
+
+    private void testUpdateAllPokemons(String query) {
+        long numberOfChanges = emf.callInTransaction(em -> em.createQuery(query).executeUpdate());
+        assertThat("All pokemons should be updated", numberOfChanges, is(equalTo(POKEMONS_COUNT)));
+
+        long numberOfPokemonsWithLengthChanged = getAllPokemons()
+                .filter(pokemon -> pokemon.getLength() == 1)
+                .count();
+        assertThat("All pokemons should have increased length", numberOfPokemonsWithLengthChanged, is(equalTo(POKEMONS_COUNT)));
+    }
+
+    public void testSelectQueryLengthInAssignmentAndExpression() {
+        List<Pokemon> pokemonsWithIdOne  = emf.callInTransaction(em -> em.createQuery(
+                "SELECT this FROM Pokemon WHERE id + length = length + 1", Pokemon.class).getResultList());
+        assertThat("Number of pokemons with ID = 1", pokemonsWithIdOne.size(), is(equalTo(1)));
+    }
+
+    public void testDeleteQueryLengthInExpressionOnLeft() {
+        assertThat("Number of remaining pokemons", getAllPokemons().count(), is(equalTo(POKEMONS_COUNT)));
+        int numberOfChanges = emf.callInTransaction(em -> em.createQuery(
+                "DELETE FROM Pokemon WHERE length = id - 1").executeUpdate());
+        assertThat("Number of pokemons with ID = 1 deleted", numberOfChanges, is(equalTo(1)));
+        assertThat("Number of remaining pokemons", getAllPokemons().count(), is(equalTo(POKEMONS_COUNT - 1)));
+    }
+
+    public void testDeleteQueryLengthInExpressionOnRight() {
+        assertThat("Number of remaining pokemons", getAllPokemons().count(), is(equalTo(POKEMONS_COUNT)));
+        int numberOfChanges = emf.callInTransaction(em -> em.createQuery(
+                "DELETE FROM Pokemon WHERE id = length + 1").executeUpdate());
+        assertThat("Number of pokemons with ID = 1 deleted", numberOfChanges, is(equalTo(1)));
+        assertThat("Number of remaining pokemons", getAllPokemons().count(), is(equalTo(POKEMONS_COUNT - 1)));
+    }
+
+    private Stream<Pokemon> getAllPokemons() {
+        return emf.callInTransaction(em -> em.createQuery(
+                "SELECT p FROM Pokemon p", Pokemon.class).getResultStream());
+    }
+
 }

jpa/org.eclipse.persistence.jpa.jpql/src/main/java/org/eclipse/persistence/jpa/jpql/AbstractGrammarValidator.java

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2006, 2024 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2022 IBM Corporation. All rights reserved.
+ * Copyright (c) 2024 Contributors to the Eclipse Foundation. 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
@@ -1791,35 +1792,6 @@ protected final boolean isNewerThanOrEqual(JPAVersion version) {
         return getJPAVersion().isNewerThanOrEqual(version);
     }
 
-    /**
-     * Determines whether the given sequence of characters is a numeric literal or not. There are
-     * two types of numeric literal that is supported:
-     * <ul>
-     *    <li>Decimal literal</li>
-     *    <li>Hexadecimal literal</li>
-     * </ul>
-     *
-     * @param text The sequence of characters to validate
-     * @return <code>true</code> if the given sequence of characters is a valid numeric literal;
-     * <code>false</code> otherwise
-     */
-    protected boolean isNumericLiteral(String text) {
-
-        // The ending 'l' or 'L' for a long number has to be removed, Java will not parse it
-        if (text.endsWith("l") || text.endsWith("L")) {
-            text = text.substring(0, text.length() - 1);
-        }
-
-        // Simply try to parse it as a double number (integer and hexadecimal are handled as well)
-        try {
-            Double.parseDouble(text);
-            return true;
-        }
-        catch (Exception e2) {
-            return false;
-        }
-    }
-
     /**
      * Determines whether the JPA version for which the JPQL grammar was defined represents a version
      * that is older than the given version.
@@ -4394,15 +4366,14 @@ public void visit(NullIfExpression expression) {
     @Override
     public void visit(NumericLiteral expression) {
 
-        String text = expression.getText();
-
         // - Exact numeric literals support the use of Java integer literal syntax as well as SQL
         //   exact numeric literal syntax
         // - Approximate literals support the use Java floating point literal syntax as well as SQL
         //   approximate numeric literal syntax
         // - Appropriate suffixes can be used to indicate the specific type of a numeric literal in
         //   accordance with the Java Language Specification
-        if (!isNumericLiteral(text)) {
+        if (!expression.hasValidValue()) {
+            String text = expression.getText();
             int startPosition = position(expression);
             int endPosition   = startPosition + text.length();
             addProblem(expression, startPosition, endPosition, NumericLiteral_Invalid, text);

jpa/org.eclipse.persistence.jpa.jpql/src/main/java/org/eclipse/persistence/jpa/jpql/WordParser.java

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2006, 2022 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2022 IBM Corporation. All rights reserved.
+ * Copyright (c) 2024 Contributors to the Eclipse Foundation. 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
@@ -256,6 +257,7 @@ public int length() {
      */
     public void moveBackward(CharSequence word) {
         cursor -= word.length();
+        wordEndPosition();
     }
 
     /**

jpa/org.eclipse.persistence.jpa.jpql/src/main/java/org/eclipse/persistence/jpa/jpql/parser/AbstractEncapsulatedExpression.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2006, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024 Contributors to the Eclipse Foundation. 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
@@ -306,4 +307,19 @@ else if (hasSpaceAfterIdentifier) {
      * like content assist
      */
     protected abstract void toParsedTextEncapsulatedExpression(StringBuilder writer, boolean actual);
+
+    /**
+     * Should be reverted if Jakarta Data mode is enabled and the expression doesn't contain parenthesis.
+     * For example, the query {@code delete from Box where length = 1} contains function name {@code length}.
+     * The function {@code length} expects parameters but there are not parameters in the query.
+     * Then {@code length} is not a function but a state field with an implicit identification variable this, ie.
+     * the query is equivalent to {@code delete from Box where this.length = 1}.
+     *
+     * @return Should be reverted and parsed again as a different expression or should be accepted as parsed expression
+     */
+    @Override
+    protected boolean shouldBeReverted() {
+        return getRoot().isJakartaData() && !hasLeftParenthesis();
+    }
+
 }

jpa/org.eclipse.persistence.jpa.jpql/src/main/java/org/eclipse/persistence/jpa/jpql/parser/AbstractExpression.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2006, 2024 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024 Contributors to the Eclipse Foundation. 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
@@ -516,6 +517,22 @@ public final JPQLExpression getRoot() {
         return (parent == null) ? (JPQLExpression) this : parent.getRoot();
     }
 
+    /**
+     * Returns closest nested expression that encapsulates this expression,
+     * or the root expression if not inside a nested expression.
+     *
+     * @return  Parent expression
+     */
+    public final ParentExpression getParentExpression() {
+        if (this instanceof ParentExpression parentExpression) {
+            return parentExpression;
+        } else if (parent == null) {
+            return null;
+        } else {
+            return parent.getParentExpression();
+        }
+    }
+
     /**
      * Returns the encapsulated text of this {@link AbstractExpression}, which can be used in various
      * ways, it can be a keyword, a literal, etc.
@@ -1133,6 +1150,17 @@ public String toParsedText() {
      */
     protected abstract void toParsedText(StringBuilder writer, boolean actual);
 
+    /**
+     * Whether this expression is not valid and should be discarded. If it returns true,
+     * the parser will be reverted to the state before this expression was parsed
+     * and it will attempt to parse a different expression.
+     *
+     * @return True if this expression is invalid and should be discarded, otherwise false. By default returns false, should be overriden if expression should be reverted.
+     */
+    protected boolean shouldBeReverted() {
+        return false;
+    }
+
     @Override
     public final String toString() {
         // toString() should only be called during debugging, thus the cached parsed text

jpa/org.eclipse.persistence.jpa.jpql/src/main/java/org/eclipse/persistence/jpa/jpql/parser/AbstractFromClause.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2006, 2024 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024 Contributors to the Eclipse Foundation. 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
@@ -343,7 +344,7 @@ else if (hierarchicalQueryClause == null) {
             identificationVariableDeclaration.hasRangeVariableDeclaration() && identificationVariableDeclaration.getRangeVariableDeclaration() instanceof RangeVariableDeclaration rangeVariableDeclaration &&
             rangeVariableDeclaration.hasIdentificationVariable() && rangeVariableDeclaration.getIdentificationVariable() instanceof IdentificationVariable identificationVariable &&
             Expression.THIS.equals(identificationVariable.getText())) {
-            this.getRoot().setGenerateThisPrefix(true);
+            this.getParentExpression().setGenerateThisPrefix(true);
         }
     }