Question

Here are the sequences leading to the question :

1. I have a Team record, and 3 Player records in the database. Team entity has a List that is using FetchType.LAZY, CascadeType.ALL
2. The search button on the webui is clicked
3. Query in the server side using JPA query is invoked, finding all the Team records, in this case, only 1 record of the team entity returned from the query (which has a proxy of the list of player entities)
4. Map this teamEntity to a DTO, and return this DTO to the webui, skipping the mapping of the list of player entities
5. Webui renders the DTO in a html form, ready to receive modifications from the user
6. User modifies the team’s properties, like the date of when it’s founded
7. The save button on the webui is clicked
8. Converting the DTO to the team entity, to be used to update the already existing team record
9. But in this case, if i were to use the em.merge(teamEntity), the team record will be updated, but what will happen to the list of players ? Because when converting from DTO to the team entity, the teamEntity has an empty list of players entities. And after merging, i notice that the teamEntity has 0 size of the details. But after refreshing that entity, em.refresh(teamEntity), it will return 3 of the detail size.

Im confused on :

1. Why is it the size is 0 after merged ? It’s like not representing the record anymore
2. Before doing the test, i was thinking that the details will be removed since im merging a teamEntity with an empty detail.

Please enlighten me 🙂

Thank you !

Answer 1

JPA Specification says:

The semantics of the merge operation
applied to an entity X are as follows:

• If X is a detached entity, the state
  of X is copied onto a pre-existing
  managed entity instance X’ of the same
  identity or a new managed copy X’ of X
  is created.

• If X is a new entity
  instance, a new managed entity
  instance X’ is created and the state
  of X is copied into the new managed
  entity instance X’.

• If X is a
  removed entity instance, an
  IllegalArgumentException will be
  thrown by the merge operation (or the
  transaction commit will fail).

• If X
  is a managed entity, it is ignored by
  the merge operation, however, the
  merge operation is cascaded to
  entities referenced by relationships
  from X if these relationships have
  been annotated with the cascade
  element value cascade=MERGE or
  cascade=ALL annotation.

• For all
  entities Y referenced by relationships
  from X having the cascade element
  value cascade=MERGE or cascade=ALL, Y
  is merged recursively as Y’. For all
  such Y referenced by X, X’ is set to
  reference Y’. (Note that if X is
  managed then X is the same object as
  X’.)

• If X is an entity merged to X’,
  with a reference to another entity Y,
  where cascade=MERGE or cascade=ALL is
  not specified, then navigation of the
  same association from X’ yields a
  reference to a managed object Y’ with
  the same persistent identity as Y.

As you can see, there is no magic here. The state of detached instance is copied into the newly created managed instance. Since your detached instance has an empty list, managed instance would have it too.

Further behaviour depends on ownership of relationship, since representation in the database reflects the owning side of relationship:

• If Team is the owning side, relationships between Team and Players will be destroyed during flush (but Player itself would survive unless you have orphanRemoval = true on your relationship).
• Otherwise having the empty list in Team doesn’t affect the database.

If you refresh the Team before flushing the context, all properties of Team are rewritten by values from the database, therefore list of Players is restored (since the empty list of players wasn’t flushed yet).

If you call flush() before calling refresh(), and Team is the owning side, list will be empty, since destruction of relationships was propagated to the database during flush().