Cascade types and behavior in Spring Boot - Step-by-Step Execution

Concept Flow - Cascade types and behavior

Start Operation on Parent Entity

↓

Check Cascade Type

↓

ALL

↓

Apply to Child Entities

↓

Execute DB Operation on Parent and Children

↓

End

When you perform an action on a parent entity, the cascade type decides if and how that action applies to its related child entities.

Execution Sample

Spring Boot

@Entity
class Parent {
  @OneToMany(cascade = CascadeType.PERSIST)
  List<Child> children;
}

parentRepository.save(parent);

Saving a parent entity with CascadeType.PERSIST also saves its new child entities automatically.

Execution Table

Step	Operation on Parent	Cascade Type	Action on Children	Database Operation
1	Call save(parent)	CascadeType.PERSIST	Persist new children	Insert parent and children rows
2	Call remove(parent)	CascadeType.PERSIST	No action on children	Delete parent row only
3	Call save(parent)	CascadeType.ALL	Persist new children	Insert parent and children rows
4	Call remove(parent)	CascadeType.ALL	Remove children	Delete children and parent rows
5	Call save(parent)	No cascade	No action on children	Insert parent row only
6	Call remove(parent)	No cascade	No action on children	Delete parent row only
7	End	-	-	-

💡 Operations stop after applying cascade rules and database actions.

Variable Tracker

Variable	Start	After Step 1	After Step 4	Final
parent	Detached	Managed (saved)	Managed (saved)	Managed
children	Detached	Managed (persisted if cascade)	Removed if cascade REMOVE	Depends on cascade

Key Moments - 2 Insights

Why don't children get deleted when CascadeType.PERSIST is used and parent is removed?

Because CascadeType.PERSIST only cascades save operations, not remove. See execution_table rows 2 and 4 for difference.

What happens if no cascade type is set and parent is saved?

Only the parent is saved; children remain detached and are not saved automatically. See execution_table row 5.

Visual Quiz - 3 Questions

Look at the execution table, what happens to children when parent is removed with CascadeType.ALL?

A Children are also removed from the database

B Children remain unchanged

C Children are saved again

D Operation fails with error

💡 Hint

Check execution_table row 4 for CascadeType.ALL remove operation

At which step do children get persisted automatically when saving parent?

A Step 2

B Step 1

C Step 5

D Step 6

💡 Hint

Look at execution_table rows where CascadeType.PERSIST is used on save

If cascade is removed, what changes in the database operations when saving parent?

A Children are saved automatically

B Both parent and children are deleted

C Only parent is saved, children are ignored

D Children are removed

💡 Hint

Refer to execution_table row 5 for no cascade save behavior

Concept Snapshot

Cascade Types in Spring Boot JPA:
- CascadeType.PERSIST: saves new children when parent saved
- CascadeType.REMOVE: deletes children when parent deleted
- CascadeType.ALL: applies all cascade operations
- No cascade: parent operations do not affect children
Use cascade to control related entity operations automatically.

Full Transcript

In Spring Boot JPA, cascade types control how operations on a parent entity affect its child entities. When you save or delete a parent, cascade settings decide if children are also saved or deleted. For example, CascadeType.PERSIST saves new children when the parent is saved but does not delete children when the parent is removed. CascadeType.ALL applies all operations including save and delete to children. Without cascade, operations on the parent do not affect children. This visual trace shows step-by-step how different cascade types behave during save and remove operations.

Practice

1. What does the CascadeType.ALL option do in Spring Boot JPA?

easy

A. It applies all cascade operations including persist, merge, remove, refresh, and detach.

B. It only cascades the persist operation to related entities.

C. It disables all cascade operations.

D. It only cascades the remove operation to related entities.

Solution

1. Step 1: Understand CascadeType.ALL meaning

   CascadeType.ALL means all cascade operations are applied to related entities automatically.

2. Step 2: Identify included operations

   These operations include persist, merge, remove, refresh, and detach, covering all common entity lifecycle events.

3. Final Answer:

   It applies all cascade operations including persist, merge, remove, refresh, and detach. -> Option A

4. Quick Check:

   CascadeType.ALL = all cascade operations [OK]

Hint: ALL means every cascade action is applied automatically [OK]

Common Mistakes:

• Thinking ALL only means persist or remove
• Confusing cascade with fetch types
• Assuming cascade disables operations

2. Which of the following is the correct syntax to apply cascade persist on a JPA relationship in Spring Boot?

easy

A. @OneToMany(cascade = "persist")

B. @OneToMany(cascade = CascadeType.PERSIST)

C. @OneToMany(cascade = {"persist"})

D. @OneToMany(cascade = CascadeType.ALL.PERSIST)

Solution

1. Step 1: Recall correct cascade syntax

   The cascade attribute expects an array or single enum value of type CascadeType.

2. Step 2: Validate each option

   @OneToMany(cascade = CascadeType.PERSIST) uses correct enum CascadeType.PERSIST. String-based options like "persist" or {"persist"} are incorrect. CascadeType.ALL.PERSIST uses invalid enum chaining.

3. Final Answer:

   @OneToMany(cascade = CascadeType.PERSIST) -> Option B

4. Quick Check:

   Use CascadeType enums, not strings [OK]

Hint: Use CascadeType.PERSIST enum, not string quotes [OK]

Common Mistakes:

• Using string values instead of enum constants
• Trying to chain enums like ALL.PERSIST
• Omitting the cascade attribute entirely

3. Given the following code snippet, what happens when parentRepository.delete(parent) is called?

@Entity
class Parent {
  @OneToMany(cascade = CascadeType.REMOVE)
  List<Child> children;
}

medium

A. An exception is thrown because cascade REMOVE is invalid here.

B. Only the parent entity is deleted; children remain in the database.

C. Both parent and all its children are deleted from the database.

D. Children are detached but not deleted; parent is deleted.

Solution

1. Step 1: Understand CascadeType.REMOVE effect

   CascadeType.REMOVE means deleting the parent also deletes all related children automatically.

2. Step 2: Apply to the delete operation

   Calling delete on parent triggers removal of parent and cascades delete to all children in the list.

3. Final Answer:

   Both parent and all its children are deleted from the database. -> Option C

4. Quick Check:

   REMOVE cascades delete to children [OK]

Hint: REMOVE cascades delete to related entities [OK]

Common Mistakes:

• Assuming children remain after parent delete
• Confusing REMOVE with DETACH or REFRESH
• Thinking cascade REMOVE causes errors

4. Identify the error in this code snippet related to cascade types:

@Entity
class Order {
  @OneToOne(cascade = CascadeType.MERGE)
  Payment payment;
}

// Later in code
orderRepository.save(order);

What issue might occur?

medium

A. The payment entity will not be saved if it is new, causing an error.

B. The cascade MERGE will cause duplicate payment entries.

C. The code will throw a syntax error due to cascade misuse.

D. The order entity will not be saved because cascade is missing.

Solution

1. Step 1: Understand CascadeType.MERGE behavior

   CascadeType.MERGE only updates existing entities; it does not persist new ones automatically.

2. Step 2: Analyze save operation with new payment

   If payment is new (not yet saved), save(order) won't persist payment, causing an error or missing data.

3. Final Answer:

   The payment entity will not be saved if it is new, causing an error. -> Option A

4. Quick Check:

   MERGE does not persist new entities [OK]

Hint: MERGE updates only; use PERSIST to save new entities [OK]

Common Mistakes:

• Assuming MERGE saves new entities
• Confusing syntax errors with runtime behavior
• Ignoring cascade effects on related entities

5. You have a Customer entity with a @OneToMany relationship to Order entities. You want to ensure that when a customer is deleted, all their orders are also deleted, but when an order is updated, the customer should not be affected. Which cascade type configuration is best?

hard

A. @OneToMany(cascade = CascadeType.DETACH)

B. @OneToMany(cascade = CascadeType.ALL)

C. @OneToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})

D. @OneToMany(cascade = CascadeType.REMOVE)

Solution

1. Step 1: Identify cascade needed for delete

   To delete all orders when customer is deleted, CascadeType.REMOVE is required.

2. Step 2: Avoid affecting customer on order update

   Using only REMOVE avoids cascading updates or persists from orders to customer, so customer stays unchanged on order update.

3. Final Answer:

   @OneToMany(cascade = CascadeType.REMOVE) -> Option D

4. Quick Check:

   REMOVE cascades delete only, no update cascade [OK]

Hint: Use REMOVE to cascade deletes only, not updates [OK]

Common Mistakes:

• Using ALL cascades causing unwanted updates
• Using PERSIST or MERGE alone missing delete cascade
• Confusing DETACH with delete cascade