Join fetch for optimization in Spring Boot - Step-by-Step Execution

Concept Flow - Join fetch for optimization

Start Query

↓

Identify Entities to Fetch

↓

Add JOIN FETCH Clause

↓

Execute Single Query

↓

Load Parent and Child Entities Together

↓

Return Optimized Result

The flow shows how adding a JOIN FETCH clause in a query loads related entities in one go, avoiding multiple database hits.

Execution Sample

Spring Boot

String jpql = "SELECT p FROM Parent p JOIN FETCH p.children WHERE p.id = :id";
Parent parent = entityManager.createQuery(jpql, Parent.class)
  .setParameter("id", 1L)
  .getSingleResult();

This code fetches a Parent entity and its children in one query to optimize performance.

Execution Table

Step	Action	JPQL Query	Database Query Executed	Entities Loaded	Result
1	Prepare JPQL with JOIN FETCH	SELECT p FROM Parent p JOIN FETCH p.children WHERE p.id = :id	No query yet	None	JPQL ready
2	Set parameter id=1	Same as above	No query yet	None	Parameter set
3	Execute query	Same as above	SELECT p.*, c.* FROM Parent p JOIN Child c ON p.id = c.parent_id WHERE p.id = 1	Parent with children	Single query returns parent and children
4	Return result	Same as above	Query done	Parent entity with children loaded	Parent object with children accessible

💡 Query executed once with JOIN FETCH, loading parent and children together, avoiding multiple queries.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
jpql		SELECT p FROM Parent p JOIN FETCH p.children WHERE p.id = :id	Same	Same	Same
parameter id	unset	unset	1	1	1
parent	null	null	null	Parent entity with children loaded	Parent entity with children loaded

Key Moments - 2 Insights

Why do we add JOIN FETCH instead of just JOIN?

JOIN FETCH tells JPA to load the related entities eagerly in the same query, avoiding lazy loading multiple queries. See execution_table step 3 where one query loads both parent and children.

What happens if we omit JOIN FETCH and just use JOIN?

Without JOIN FETCH, JPA loads the parent first, then loads children lazily in separate queries, causing N+1 query problem. The execution_table shows only one query with JOIN FETCH.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the database query actually executed?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Check the 'Database Query Executed' column in execution_table rows.

According to variable_tracker, what is the value of 'parent' after Step 3?

A Parent entity with children loaded

B null

C JPQL query string

D Parameter id value

💡 Hint

Look at the 'parent' row and 'After Step 3' column in variable_tracker.

If we remove JOIN FETCH from the JPQL, what changes in the execution flow?

A One query loads parent and children together

B Multiple queries load children lazily after parent

C No query is executed

D Parameter setting fails

💡 Hint

Refer to key_moments explanation about JOIN vs JOIN FETCH.

Concept Snapshot

Join fetch in JPQL loads related entities eagerly in one query.
Syntax: SELECT p FROM Parent p JOIN FETCH p.children WHERE ...
Avoids multiple queries and N+1 problem.
Improves performance by fetching parent and children together.
Use when you know you need related data immediately.

Full Transcript

Join fetch is a way to optimize database queries in Spring Boot JPA. Instead of loading a parent entity and then lazily loading its children in separate queries, join fetch loads both parent and children in one query. The flow starts by preparing a JPQL query with JOIN FETCH, setting parameters, executing the query which runs a single SQL join query, and returning the parent entity with children loaded. Variables like the JPQL string, parameters, and the parent entity change state step by step. Key points include that JOIN FETCH triggers eager loading, avoiding multiple queries. The visual quiz tests understanding of when the query runs, variable states, and the effect of removing JOIN FETCH. This technique improves performance by reducing database hits.