JPA bidirectional relations: structure in Database - jpa

Question

I'm starting using JPA in Netbeans with a Glassfish server + Derby Database, and I have some doubts on its behavior. I did the following experiment: I defined an entity "User" with the property
#OneToMany(cascade=ALL, mappedBy="user")
public List<Thing> getThings() {
return things;
}
and the entity "Thing" with the property
#ManyToOne
public Cook4User getUser() {
return user;
}
Then I persisted one user and added one "Thing" to it. Everything all right, I can see the two tables "User" and "Thing" with one entry each, with the second table having a foreign key indicating the user id.
Then I removed the element from the "Thing" table, ran a select statement to recover the user, called the getThings() method on it and... I still found the element that I had removed from the Thing table! How is it possible? Where is it stored? I can't see it nowhere in the DB! Thanks for clearing things up to me.
EDIT: I tried to isolate the lines of code that produce the issue.
#PersistenceContext
private EntityManager em;
User user = new User();
em.persist(user);
Thing thing = new Thing();
em.persist(thing);
user.getThings().add(thing);
em.remove(thing);
user = em.find(User.class, userid);
logger.log(Level.INFO, "user still contains {0} things", user.getThings().size());
\\thing is still there!

Answer 1

In the form of a JUnit test with SpringRunner and Hibernate as the JPA implementation:
#RunWith(SpringJUnit4ClassRunner.class)
#ContextConfiguration("classpath:spring-context.xml")
public class TestThings {
private final Logger log = LoggerFactory.getLogger(TestThings.class);
#PersistenceContext
private EntityManager em;
#Test
#Transactional
public void does_not_remove_thing() {
Cook4User user = new Cook4User();
em.persist(user);
Thing thing = new Thing();
em.persist(thing);
user.getThings().add(thing);
user = em.find(Cook4User.class, user.getId());
user.getThings().forEach((t) -> log.info("1 >> Users thing: {}", t.getId()));
em.remove(thing);
em.flush();
user = em.find(Cook4User.class, user.getId());
user.getThings().forEach((t) -> log.info("2 >> Users thing: {}", t.getId()));
assertThat(user.getThings()).isEmpty();
}
#Test
#Transactional
public void removes_thing_when_removed_from_owning_side() {
Cook4User user = new Cook4User();
em.persist(user);
Thing thing = new Thing();
em.persist(thing);
user.getThings().add(thing);
user = em.find(Cook4User.class, user.getId());
user.getThings().forEach((t) -> log.info("1 >> Users thing: {}", t.getId()));
user.getThings().remove(thing);
user = em.find(Cook4User.class, user.getId());
user.getThings().forEach((t) -> log.info("2 >> Users thing: {}", t.getId()));
assertThat(user.getThings()).isEmpty();
}
}
The first test does_not_remove_thing is per your question and fails as you have experienced, this is the output of that test with hibernate.show_sql logging set to true:
Hibernate:
insert
into
Cook4User
(id)
values
(null)
Hibernate:
insert
into
Thing
(id, user_id)
values
(null, ?)
[main] INFO TestThings - 1 >> Users thing: 1
[main] INFO TestThings - 2 >> Users thing: 1
java.lang.AssertionError: expecting empty but was:<[x.Thing#276]>
The second test removes_thing_when_removed_from_owning_side passes with output:
Hibernate:
insert
into
Cook4User
(id)
values
(null)
Hibernate:
insert
into
Thing
(id, user_id)
values
(null, ?)
[main] INFO TestThings - 1 >> Users thing: 1
So it looks like removing your Thing from the owning side of the relationship (he he) is the way to go.
Although, I must be honest, I'm not sure why exactly that works and your way does not. I would understand if you removed your Thing from a detached entity but that was not the case. Also, I was expecting a delete query after calling em.remove(thing) for Thing somewhere but nothing (I added em.flush() to try force that).
Maybe someone else can shed some light on the finer mechanics of what's going on here?