JPA/Hibernate - one-to-many list vs set optimization - list

Question

I have a simple one-to-many bidirectional association between Account (one) <--> Transaction (many)
#Entity
public class Account {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
...
#OneToMany(mappedBy = "account")
private List<Transaction> transactions = new ArrayList<>();
#Entity
public class Transaction {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
...
#ManyToOne
#JoinColumn(name = "ACCOUNT_ID")
private Account account;
#Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Transaction that = (Transaction) o;
return Objects.equals(id, that.id);
}
#Override
public int hashCode() {
return 31;
}
}
The account (ID = 1) already has one transaction. And, I'm adding adding another transaction to the account. The block of code runs within the context of a transaction. All assertions pass:
execute(entityManager -> {
Account account = entityManager.find(Account.class, 1L);
//assertThat(account.getTransactions().size(), is(1));
Transaction t1 = new Transaction();
t1.setTitle("Buy veggies");
t1.setAmount(100);
account.getTransactions().add(t1); // ###
t1.setAccount(account);
entityManager.persist(t1);
//assertThat(account.getTransactions().size(), is(2));
});
Note the line marked ###, where the many side of the collection is loaded. I expected Hibernate to issue a SELECT on the 'Transaction' entity but it didn't. I'm including the logs below:
Hibernate:
select
account0_.id as id1_0_0_,
account0_.initial_balance as initial_2_0_0_,
...
from
account account0_
where
account0_.id=?
17:06:22.970 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [1] as [BIGINT] - [1]
Hibernate:
insert
into
transaction
(id, account_id, amount, title)
values
(null, ?, ?, ?)
17:06:22.973 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [1] as [BIGINT] - [1]
17:06:22.973 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [2] as [DOUBLE] - [100.0]
17:06:22.973 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [3] as [VARCHAR] - [Buy veggies]
At the end of the transaction, I verified the integrity of the data and all looks fine. The following assertion (run a new transaction context) passed:
execute(entityManager -> {
Account account = entityManager.find(Account.class, 1L);
assertThat(account.getTransactions().size(), is(2));
});
Could someone please explain why the account.getTransactions().add(t1) did not trigger a sql SELECT? Is this Hibernate's optimization or am I missing anything?
To add to the confusion, I changed the collection to Set (everything else remains the same as before).
#OneToMany(mappedBy = "account")
private Set<Transaction> transactions = new HashSet<>();
And now, I noticed what I expected in the logs - There was indeed a sql SELECT issued when account.getTransactions().add(t1) was called:
Hibernate:
select
account0_.id as id1_0_0_,
account0_.initial_balance as initial_2_0_0_,
...
from
account account0_
where
account0_.id=?
17:09:23.056 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [1] as [BIGINT] - [1]
Hibernate:
select
transactio0_.account_id as account_4_6_0_,
transactio0_.id as id1_6_0_,
transactio0_.id as id1_6_1_,
transactio0_.account_id as account_4_6_1_,
transactio0_.amount as amount2_6_1_,
transactio0_.title as title3_6_1_
from
transaction transactio0_
where
transactio0_.account_id=?
17:09:23.057 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [1] as [BIGINT] - [1]
Hibernate:
insert
into
transaction
(id, account_id, amount, title)
values
(null, ?, ?, ?)
17:09:23.059 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [1] as [BIGINT] - [1]
17:09:23.059 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [2] as [DOUBLE] - [100.0]
17:09:23.059 [main] TRACE o.h.type.descriptor.sql.BasicBinder - binding parameter [3] as [VARCHAR] - [Buy veggies]
hibernate-core 5.4.12.Final in spring-boot 2.2.5.RELEASE

Answer 1

When adding to a List, the current entries don't matter, if it's a Set you have to load the entries so that you can verify that you wouldn't try adding a duplicate value. The default FetchType of #OneToMany is FetchType.LAZY, hence the missing select statement. Accessing the List entries triggers a fetch.