When using JPA and Hibernate, the fetch type adds a good amount of impact to an application's performance. We should always fetch as much data as we need to fulfill a given business requirement. To do so, we set the associated entities FetchType as LAZY. When we set these associated entities fetch type as LAZY, we implement a nested select in our applications, because we are not aware how these associations are fetched under the abstraction provided by ORM frameworks. Nested selects are nothing but two queries, where one is the outer, or main, query (which fetches the result from a table) and the other is executed for each row as a result of the main query (to fetch the corresponding or related data from other table/s).

The following example shows how we unintentionally implement something that does nested select:

Account account = this.em.find(Account.class, accountNumber);
List<Transaction> lAccountTransactions = account.getTransaction();
for(Transaction transaction : lAccountTransactions){
  //.....
}

Mostly, a developer tends to write code like the preceding example, and won't realize how an ORM framework like Hibernate could be fetching data internally. Here, ORM frameworks like Hibernate execute one query to get the account, and a second query to get transactions for that account. Two queries are fine, and won't impact the performance much. These two queries are for one association in an entity.

Let's suppose that we have five associations in the Account entity: Transactions, UserProfile, Payee, and so on. When we try to fetch each association from the Account entity, the framework executes one query for each association, resulting in 1 + 5 = 6 queries. Six queries won't impact much, right? These queries are for one user, so what if the number of concurrent users of our application is 100? Then we will have 100 * (1 + 5) = 600 queries. Now, that is something that would impact the performance. This 1 + 5 queries while fetching Account is called the n + 1 problem in Hibernate. We will see some approaches to avoiding this problem in the Hibernate performance tuning section of this chapter.