TRUNCATE TABLE in Spring Data JPA

Last updated: January 8, 2024

Written by: Mateusz Szablak

Reviewed by: Grzegorz Piwowarek

Spring Data

Spring Data JPA

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

Spring JPA provides an easy way to interact with databases by abstracting the low-level details of working with SQL. When working with databases, we might want to truncate a table, which will delete all the data without removing the table structure itself.

In this tutorial, we’ll explore different ways to truncate a table using Spring JPA.

2. Extending a JPA Repository Interface

As we know, Spring JPA provides several predefined Repository interfaces to perform operations on entities. Let’s extend one of them, adding a custom query method that executes a truncate statement:

@Repository
public interface MyEntityRepository extends CrudRepository<MyEntity, Long> {
    @Modifying
    @Transactional
    @Query(value = "TRUNCATE TABLE my_entity", nativeQuery = true)
    void truncateTable();
}

In this example, we defined a desired SQL statement using the @Query annotation. We also annotated the method with @Modifying to indicate that it modifies the table and set the nativeQuery attribute to true because there’s no JQL (or HQL) equivalent.

Remember that we should call it within a transaction, so we also used the @Transactional annotation.

3. Using EntityManager

The EntityManager is a core interface of JPA that provides an interface to interact with entities and the database. We can also use it to execute SQL queries, including truncating a table.

Let’s implement a statement using this interface:

@Repository
public class EntityManagerRepository {
    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void truncateTable(String tableName) {
        String sql = "TRUNCATE TABLE " + tableName;
        Query query = entityManager.createNativeQuery(sql);
        query.executeUpdate();
    }
}

In this example, we injected EntityManager into our repository bean and used the createNativeQuery() method to implement a native SQL query that truncates the table specified by the tableName parameter. We then executed the defined query using the executeUpdate() method.

4. Using JdbcTemplate

The JdbcTemplate is another component of Spring Data that provides a high-level way to interact with databases over JDBC. We can use exposed methods to execute our custom queries.

Let’s truncate a table using the given component:

@Repository
public class JdbcTemplateRepository {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void truncateTable(String tableName) {
        String sql = "TRUNCATE TABLE " + tableName;
        jdbcTemplate.execute(sql);
    }
}

In this example, we injected the JdbcTemplate into our repository by using an @Autowired annotation. After that, we used the execute() method to execute a SQL statement that truncates the table specified by the tableName parameter.

5. Conclusion

In this article, we explored several ways to truncate a table using Spring JPA. We can choose between extending the Repository interface and executing queries directly using the EntityManager or JdbcTemplate components, depending on specific requirements and preferences.

It’s important to exercise caution when truncating a table, as it deletes all data.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.