Spring Boot - JPA Custom Delete Operation

Posted on In

Persist/Merge/Delete Operation needs to be done in a transaction. This article shows how to use @Transactional annotation in Spring Boot to delete records from a database table.

JPA Custom Delete Operation and @Transactional

In JPA (Java Persistence API), the @Transactional annotation is required for delete operations because of how JPA manages entity state and interacts with the database transaction. Here’s why:

  1. JPA Operations Require a Transaction

    • JPA operations (like persist, merge, remove) need to be executed within a transactional context.
    • If there is no active transaction, the EntityManager may not properly propagate changes to the database.

  2. Delete Needs to be Committed

    • The delete operation in JPA works by marking an entity for removal and later synchronizing it with the database.
    • Without a transaction, changes might not be committed, leading to inconsistent behavior.

  3. Spring Data JPA Defaults

    • Spring Data JPA by default makes @Transactional optional for read-only operations (findById, findAll).
    • However, modifying operations (like deleteById, delete) must be explicitly marked as @Transactional when working with custom repositories.

  4. Avoid LazyInitializationException

    • If the entity has lazy-loaded relationships, deletion might trigger additional queries.
    • If @Transactional is missing, you may encounter LazyInitializationException when trying to access uninitialized proxy objects.

  5. Cascading & Orphan Removal

    • If an entity has cascade delete or orphan removal, deleting a parent entity may trigger multiple delete queries.
    • A transaction ensures that all associated deletes succeed or are rolled back together.

Spring Data JPA Example

If you’re using Spring Data JPA, the default CrudRepository methods (like deleteById) already run inside transactions:

1
2
3
public interface UserRepository extends JpaRepository<User, Long> {
    void deleteById(Long id);  // Already transactional in JpaRepository
}

Spring Data JPA automatically wraps these methods in a transaction, so you don’t need to add @Transactional.

But if you write custom updaate/delete methods, make sure to annotate them with @Transactional:

1
2
3
4
5
6
7
public interface UserRepository extends JpaRepository<User, Long> {

    @Transactional
    @Modifying
    @Query("DELETE FROM User u WHERE u.id = :id")
    void deleteUserById(@Param("id") Long id);
}

Here @Transactional is needed because this query is not a read-only operation. Need to have a transaction to execute this update/delete query. If you don’t add @Transactional, you may encounter an exception like jakarta.persistence.TransactionRequiredException: Executing an update/delete query.

Here we use the @Transaction annotation with default propagation level REQUIRED. This means that if there is an existing transaction, the method will execute within that transaction. If there is no transaction, a new transaction will be created.

@Modifying is needed to tell Spring Data JPA that this query is an update/delete query, not a select query.

@Query is needed to specify the JPQL query to execute.

Foreign Key Constraints

If you have foreign key constraints in your database, you may need to handle them manually when deleting records. Custom Delete JPQL/Native query will not automatically delete child records.

Error Example:

1
java.sql.SQLIntegrityConstraintViolationException: Cannot delete or update a parent row: a foreign key constraint fails (`mydatabase`.`item`, CONSTRAINT `FK4g2q77pbbf0faqae5uywbsodk` FOREIGN KEY (`cart_id`) REFERENCES `cart` (`id`))

Conclusion

When working with custom delete queries in Spring Data JPA, always remember to add @Transactional to ensure that the operation is executed within a transaction. This is essential for proper database synchronization and to avoid exceptions related to entity state management.