ObjectDB update query with enum value is not queryable

Question

I am having some difficulty updating enum fields using update queries. It appears that whenever I update an enum field with a new value, the updated value is impossible to match on for new queries. The update query works fine for other data types, but not enums.

I have tried closing the EntityManager, the EntityManagerFactory, the application, but for some reason the field cannot be matched on in its new state.

Below is a test I'm using, where the "db" instance is just a class that handles instantiation, closing and transactions for the EntityManager.

@Test
public void test() {
    db.execute(em -> em.createQuery("UPDATE Atmosphere SET setting = :setting WHERE id=:id", Atmosphere.class)
            .setParameter("setting", Atmosphere.Setting.coast)
            .setParameter("id", atmosphere1.getId()).executeUpdate());

    List<Atmosphere> results = db.retrieve(em -> em.createQuery("SELECT FROM Atmosphere WHERE id = :id", Atmosphere.class)
        .setParameter("id", atmosphere1).getResultList());
    assertFalse(results.isEmpty()); // passes
    assertEquals(Atmosphere.Setting.coast, results.get(0).getSetting()); // passes, the record is updated!

    results = db.retrieve(em -> em.createQuery("SELECT FROM Atmosphere WHERE setting = :setting", Atmosphere.class)
            .setParameter("setting", Atmosphere.Setting.coast)
            .getResultList());
    assertFalse(results.isEmpty()); // fails, no results!
}

I've inspected the row in the explorer tool as well, and can see that it is updated, but I still can't query it.

The only thing that seems to work is updating the record using EntityManager.merge().

EDIT: Turns out the issue only arises when using @Enumerated(EnumType.STRING) on the entity's enum field. Removing this fixes the issue (in objectdb 2.7.6).

Answer 1

The following code seems to work properly:

    import javax.persistence.*;

    public class T53151410 {
        public static void main(String[] args) {

            EntityManagerFactory emf = 
                Persistence.createEntityManagerFactory(
                    "objectdb:db.tmp;drop");
            EntityManager em = emf.createEntityManager();

            em.getTransaction().begin();
            em.persist(new MyEntity());
            em.getTransaction().commit();

            em.getTransaction().begin();
            System.out.println(
                em.createQuery("UPDATE MyEntity SET color = :color")
                    .setParameter("color", Color.RED).executeUpdate()
            ); 
            em.getTransaction().commit();

            System.out.println(
                em.createQuery("SELECT FROM MyEntity WHERE color = :color")
                    .setParameter("color", Color.RED).getResultList().size()
            );

            em.close();
            emf.close();
        }

        @Entity
        private static class MyEntity {
            Color color;
        }

        private static enum Color { RED, GREEN, BLUE }
    }
}

Answer 2

You are right that there is an issue with updating a STRING based enum field using an UPDATE query. This is because the parameter is always treated as ORDINAL by ObjectDB.

A simple workaround is to set the field explicitly as a string:

import javax.persistence.*;

public class T53151410
{
    public static void main(String[] args)
    {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("objectdb:db.tmp;drop");

        EntityManager em = emf.createEntityManager();

        em.getTransaction().begin();
        em.persist(new MyEntity());
        em.getTransaction().commit();

        em.getTransaction().begin();
        System.out.println(
            em.createQuery("UPDATE MyEntity SET color = :color")
                .setParameter("color", Color.RED.name()).executeUpdate()
        ); 
        em.getTransaction().commit();

        System.out.println(
            em.createQuery("SELECT FROM MyEntity WHERE color = :color")
                .setParameter("color", Color.RED).getResultList().size()
        );

        em.close();
        emf.close();
    }

    @Entity
    private static class MyEntity
    {
        @Enumerated(EnumType.STRING) Color color;
    }

    private static enum Color { RED, GREEN, BLUE }
}

Answer 3

After some experimentation I found the issue arises only when using @Enumerated(EnumType.STRING). The only workaround, as far as I can tell, is to remove the annotation to default to ordinal-type persistence (in objectdb 2.7.6).