Add "previousValue" parameter to @PostUpdate @PreUpdate handler

[trajano]

I am pretty sure this can't be done easily because we only have references and can't simply just "copy" the previous value first for @PreUpdate and @postupdate

That is saying something like

@PreUpdate
void aboutToUpdate(Entity out, Entity in) {}

@PostUpdate
void updated(Entity out, Entity in) {}

The idea I had that if a second parameter is provided namely in then it's the object that was about to be updated but detached. The thing is if it was still pointing to the same values as the out entity they'd be the same values.

So for someone to work around that in may have a transient variable containing the older values which will be dropped off the out parameter. Then they can do some manipulations.

Anyway just a random idea.

[lprimak]

Upvoted

[gavinking]

My knee-jerk is that this is really a lot harder than it sounds, and has nontrivial implications for performance.

For example, what is the expectation for associations?

Note that Hibernate offers something like this via the Interceptor API, but there the previous state is provided in the form of a flattened and deconstructed state array, which circumvents any problems with association access.

[lprimak]

In my use case, only basic values can be supported. Collections can be safely ignored and not supported.
Since weaving already keeps previous values, I would think this could be easily implemented in both hibernate and eclipselonk

[lprimak]

On the other hand, I am just guessing about the internals. Perhaps just Hibernate Interceptor needs to be standardized. Perhaps a CDI interceptor can be made to work?

What do you think Gavin?

[gavinking]

I would not attempt to standardize Interceptor itself, but I think we could consider allowing something like the following:

@PreUpdate
void onUpdate(Entity entity, AttributeUpdate<Entity,?>... attributeUpdates) { ... }

where AttributeUpdate is defined by:

interface AttributeUpdate<E,T> {
    SingularAttribute<? super E,T> attribute();
    T oldValue();
    T newValue();
}

For generic listeners I guess you would write something like:

@PreUpdate
<E> void onUpdate(E entity, AttributeUpdate<E,?>... attributeUpdates) { ... }

We would need to think very carefully about how this relates to the new EntityAgent stuff. I assume that these things would be AttributeInsert, AttributeUpdate, and AttributeDelete, corresponding to the @PreInsert, @PreUpdate, @PreDelete event types (not to @PrePersist, @PreMerge, and @PreRemove). But for EntityAgent.update(), old values are not known. Anyway, that's more of a detail I guess.

[gavinking]

But for EntityAgent.update(), old values are not known. Anyway, that's more of a detail I guess.

And in @PreUpsert, we're not even sure if they're AttributeUpdates or AttributeInserts. But these details aren't showstoppers. At worst we can just define an AttributeOverwite or whatever.

[lprimak]

This would definitely work for my use case. Thank you!