updatable | Finds packages that require updates on a python environment

One thing that is definitly a problem is

I solved the problem by restructurizing the project a little bit. The rows and columns of the specific Hall are now just stored in the model:

Models.py

Your mappings are incorrect - you'll need to look into JPA tutorials on how to map derived ids, but the error tells you what is wrong, pointing you at your ClassifiedGroup.interaction mapping(s). The PK class must use the Interaction's ID (a UUID), not the Interaction instance itself.

Yes CTE are for many things very good, but for your purpose not.

Use instead a INNER JOIN.

You need to create a separate query/prepareStatement for an update. In your case as far as I can see you need only one update query:

The problem was in the Post#commentCount field. It was mistakenly calculated through the @Formula annotation with this native subquery:

I could imagine the standard bi-directional association using @OneToMany being a maintainable yet performant solution.

To mitigate n+1 selects, one could use e.g.:

• @EntityGraph, to specify which associated data is to be loaded (e.g. one user with all of it's posts and all associated votes within one single select query)
• Hibernates @BatchSize, e.g. to load votes for multiple posts at once when iterating over all posts of a user, instead having one query for each collection of votes of each post

When it comes to restricting users to perform accesses in less performant ways, I'd argue that it should be up the API to document possible performance impacts and offer performant alternatives for different use-cases.

(As a user of an API one might always find ways to implement things in the least performant fashion:)

Using @Formula would not cause any N+1 select problem (different to @PostLoad), since the specified expression is evaluated as part of the initial select query.

(Infact, you would need to enable Hibernates byte code enhancement to be able to lazy-load the calculated @Formula property: Controlling lazy/eager loading of @Formula columns dynamically )

So even though it is a Hibernate-specific feature which needs native SQL, @Formula is probably a good and simple way to realize this.

In case the performance drawback of the correlated subquery gets significant and there are cases when the calculated property is not needed, you might additionally create a DTO projection only containing needed properties.

You might be hitting Spring issue #21674 which was fixed in Spring 5.1. You might want to upgrade, if that is an option. It seems there is a fix which ignores those kinds of methods. If that is OK for you or not, I do not know.

Some background information: Your target method is transactional, so Spring tries to create a CGLIB proxy for it. I quickly verified in a simple Spock (Groovy) test that CGLIB seems to be unable to handle methods containing spaces correctly -probably because it is simply unaware of languages like Groovy and Kotlin which allow such things. Here is a proof of concept. I used Groovy and Spock, because I am lazy and did not want to set up a Kotlin project. But I am expecting the result to be identical.

Java class under test: