I want to do a countribution where methods with batch keywords are processed through the persistence context.

[sami355-24]

While looking for query optimization, I learned about the Batch keyword provided by Data JPA. And I also learned that the performance varies depending on the presence or absence of the Batch keyword. However, when adding the Batch keyword, I found that the "IN" keyword sends the query at once, but it processes it without going through the persistence context.

In response, I thought it would be good to modify the code so that methods with the Batch keyword are processed through the persistence context. If my idea feels valid, can I do a countribution on this?

[mp911de]

Would you mind providing some pseudo-code that explains what you want to achieve? We currently have a difficult time understanding what you're up to.

[sami355-24]

I'm not familiar with English, so I used a translator to leave an issue. So the writing can be a little awkward.

First of all, I'll tell you about the code that made me think of contribution with an example.
If you use deleteAll provided by Data Jpa, delete the entity one at a time through the persistence context, so @PostRemove, which is called when the value is deleted in the persistence context, works fine. This means that the entity has been deleted from the persistence context.

@SpringBootTest
class MemberRepositoryTest {

    @Autowired
    private MemberRepository memberRepository;

    @BeforeEach
    public void setUp() {
        for (int i = 0; i < 10; i++) {
            memberRepository.save(Member.builder()
                    .clubName("test" + i)
                    .build());
        }
    }

    @Test
    @DisplayName("PostRemove is invoked when deleting using deleteAll.")
    public void deleteAllTest() {
        memberRepository.deleteAll();
    }
}

result is..

And if you delete it using the method with the Batch keyword provided by Data JPA, @PostRemove will not be called. This means that the entity has not been deleted from the persistence context.

@SpringBootTest
class MemberRepositoryTest {

    @Autowired
    private MemberRepository memberRepository;

    @BeforeEach
    public void setUp() {
        for (int i = 0; i < 10; i++) {
            memberRepository.save(Member.builder()
                    .clubName("test" + i)
                    .build());
        }
    }

    @Test
    @DisplayName("PostRemove is not invoked when deleting using DeleteAll.")
    public void deleteAllInBatchTest() {
        memberRepository.deleteAllInBatch();
    }

}

result is..

And the pseudocode of what I suggest is as follows. (I wrote the pseudocode based on the SimpleJpaRepository<T, ID>)

1. deleteAllInBatch()

function deleteAllInBatch() {
    Create a query string using the result of the getDeleteAllQueryString() method
    Create a Query object from the EntityManager
    Apply query hints

    // Suggestion start
    if (Type parameter T exists in Persistence Context)
        Delete all type parameters T present in the entity manager.
    // Suggestion end

    Execute the query
}

2. deleteAllInBatch(Iterable<T> entities)

function deleteAllInBatch(entities: Iterable<T>) {
    Check if the 'entities' parameter is not null
    if (Check if 'entities' has elements) {
        Construct the delete query string using entity name
        Apply query and bind parameters using QueryUtils

        // Suggestion start
        if (Type parameter T exists in Persistence Context)
            Delete parameters T present in the entity manager.
        // Suggestion end

        Execute the delete query
    }
}

3. deleteAllByIdInBatch(Iterable<ID> ids)

function deleteAllByIdInBatch deleteByIds(Iterable<ID> ids) {
    Check if 'ids' parameter is not null
    if (Check if 'ids' has elements) {
        if (Check if the entity has a composite ID) {
            For entities with composite ID, fetch references and delete all in batch 
            // If the deleteAllInBatch code is modified as I suggested, there is no need to modify the code here.
        } else {
            Construct the delete query string
            Construct the delete query object
            Set parameter 'ids' based on the type of 'ids' (Collection or other)
            Apply query hints and execute the delete query

            // Suggestion start
            if (Type parameter T exists in Persistence Context)
                Delete parameters present in the entity manager.
            // Suggestion end

            Execute the delete query
        }
    }
}

[sami355-24]

There was a typo in pseudocode. Methods with parameters(deleteAllByIdInBatch(Iterable<ID> ids), deleteAllInBatch(Iterable<T> entities)) have been modified to check if they exist in the entity manager and, if so, only delete them.

[sami355-24]

Hello, I'm inquiring about any updates on this issue, please review it, thank you.

[mp911de]

After discussing the proposed changes in the team we decided to not apply this change.

Both Batch methods leverage delete queries to remove objects without loading them into memory (see also their Javadoc). This is an intentional design choice to perform removal as quickly as possible and without notifying listeners.

That being said, we want to keep the design as-is. Also, we cannot call EntityManager.clear(…) because that would remove all entities from the persistence context, potentially those requiring flushing.