Allow to use Java DTOs matching the Hibernate field mapping in query parameters

[victornoel]

Hi, as discussed in #774, the following test does not pass:

@Test
    public void test() {

        doInJPA(entityManager -> {
            entityManager.persist(
                new Book()
                    .setIsbn("978-9730228236")
                    .setProperty("my", "property")
            );
        });

        doInJPA(entityManager -> {
            Book book = entityManager.unwrap(Session.class)
                .createSelectionQuery("SELECT b from Book b WHERE property = :b", Book.class)
                .setParameter(
                    "b",
                    new Property("my", "property")
                )
                .getSingleResult();

            assertEquals(
                "978-9730228236",
                book.getIsbn()
            );
        });
    }

    @Entity(name = "Book")
    @Table(name = "book")
    public static class Book {
        // ....
        @Type(JsonType.class)
        private Property property;
        // ....
    }

Two relevant points IMO:

• I shouldn't have Property to implement Serializable for this to work
  • jackson knows how to convert this to json so that it can be sent to the db, I don't see why the execution path should go through java serialization
  • also I don't always have the control on the DTOs (well in my very particular case I do, but it could happen that someone don't?)
• More implementation-oriented and performance related
  • this use case is very similar to the support of List/Map as they were recently implemented: a List, a Map or a random Java class have the same semantics in this context, they are just a DTO that needs to be converted to json before being sent to the db
  • I don't see why the execution path, that goes through JsonJavaTypeDescriptor.wrap() requires an extra conversion through string before reconstructing the original object. It's basically doing a deep copy and that seems useless.

[vladmihalcea]

@victornoel I checked it out, and the problem comes from the MutableMutabilityPlan in Hibernate that does the casting to Serializable:

public abstract class MutableMutabilityPlan<T> implements MutabilityPlan<T> {
    ...

    public Serializable disassemble(T value, SharedSessionContract session) {
        return (Serializable)this.deepCopy(value);
    }

    ...
}

Now, I doubt that Hibernate will change that since the method signature is used by the org.hibernate.type.Type interface. Since even the org.hibernate.usertype.UserType has that, I don't see how this could be implemented even with the custom Type mechanism.

I'll leave this issue Open for a while to see whether you manage to find a way to make it work given the aforementioned limitations of Hibernate.