The parser gives an error for a JPQL which refers to a "length" field with no entity alias

[OndroMih]

A duplicate of #2187.

Describe the bug

When an entity has a field named "length", it should be valid to use this field in a JPQL query. However, JPQL also supports a function of the same name "length". If the field "length" is used without an entity alias in a condition, Eclipselink confuses it with the function "length" and complains that the function is not followed by arguments in parentheses.

For example, with enitty Box that has an int field length, the following query is valid in Persistence 3.2 and 'length" should the Box entity:

UPDATE Box SET length = length + ?1

EclipseLink gives the following error when executing the query:

The left parenthesis is missing from the LENGTH expression.
The left expression is not an arithmetic expression.
The left expression is not an arithmetic expression. 

This is because Eclipselink parser treats "length" as a function and expects that it's followed by arguments.

To Reproduce

One way to reproduce is to create a simple application (e.g. a Java SE app or unit test with EclipseLink running against an embedded DB like Derby), with the following:

• some entity, e.g. Box, with an int length field (the field must have a name that's equal to some supported function name, "length" is just one example)
• execute a query without an alias, such as UPDATE Box SET length = length + ?1, or SELECT this Box WHERE length = ?1

Another, more complicate way, is to run the Jakarta Data TCK with Eclipselink as a backend. This is what I'm working on right now and that's how I discovered this bug. One of the Data TCK tests uses the query UPDATE Box SET length = length + ?1, width = width - ?1, height = height * ?2 (the source code of the query, the source code of the test that executes it and fails). Without fixing this, no Jakarta Data implementation on top of Eclipselink can pass the Data TCK.

• EclipseLink version: 5.0.0-B02, main branch today
• Java/JDK version: I use Java 21 but the same should happen on Java 17
• Entity source (mainly applied annotations): any entity with a field whose name is the same as some function supported in JPQL. For example int length

Code example:

emf = new PersistenceConfiguration("test")
                .transactionType(RESOURCE_LOCAL)
                .provider(PersistenceProvider.class.getName())
                .property(PersistenceConfiguration.JDBC_DRIVER, ClientDataSource.class.getName())
                .property(PersistenceConfiguration.JDBC_URL, "jdbc:derby:memory:test-jpa;create=true")
                .property(PersistenceConfiguration.JDBC_USER, "APP")
                .property(PersistenceConfiguration.JDBC_PASSWORD, "APP")
                .property(PersistenceConfiguration.SCHEMAGEN_DATABASE_ACTION, "drop-and-create")
                .property("eclipselink.debug", "ALL")
                .property("eclipselink.target-database", "Derby")
                .property("eclipselink.weaving", "static")
                .property("eclipselink.logging.level", "FINEST")
                .property("eclipselink.logging.level.sql", "FINEST")
                .property("eclipselink.logging.level.cache", "FINEST")
                .property("eclipselink.jpql.validation", "JPA 3.2")
                .managedClass(Box.class)
                .createEntityManagerFactory();
        em = emf.createEntityManager();
        em.getTransaction().begin();

        Query query = em.createQuery("UPDATE Box SET length = this.length + 1");
        query.executeUpdate();

        EntityTransaction tx = em.getTransaction();
        if (tx.isActive() && !tx.getRollbackOnly()) {
            tx.commit();
        }

Box.java:

@Entity
public class Box {
    @Id
    long id;
    @Column
    long length;
}

Expected behavior
For example example code above, I would expect that with the query ("UPDATE Box SET length = this.length + 1", all rows in the Box table will have the "length" value increased by 1.

Additional context

I'm going to submit a pull request with a fix and additional test cases that cover cases like this

[pzygielo]

Sounds similar:

• Length entity attribute misinterpreted as LENGTH(...) operation in JPQL #2187

[OndroMih]

Yes, it's the same thing, originated from a test in Jakarta Data. Looks like the OpenLiberty team hit the same issue as me. I didn't notice it before. I'll close my issue as a duplicate.

[Riva-Tholoor-Philip]

Thanks @OndroMih , @pzygielo