EntityGraph | Example Spring Boot REST app | Object-Relational Mapping library

What was said in the comments is correct: GraphQL (and hence SPQR, as it's merely a tool to hook the schema up) does not know anything about SQL, databases, JOINs or anything else. It's a communication protocol, the rest is up to you. As for your situation, you'd have to inject the subselection into the resolver and pass it down to SQL. In the simplest case, it can look like this (in pseudo code):

The problem is that when the code returns from findAll the entities are not managed anymore. So you have a LazyInitializationException because you are trying, outside of the scope of the session, to access a collection that hasn't been initialized already.

Adding eager make it works because it makes sure that the collection has been already initialized.

You have two alternatives:

1. Using an EAGER fetch;
2. Make sure that the entities are still managed when you return from the findAll. Adding a @Transactional to the method should work:

EclipseLink you'll notice always does an extra query for any relationship mapping unless you specify a fetchJoin annotation (or query hint, or modify the mapping with customizers) that tells it what to do, and this is independent of the relationship being eager or lazily fetched. Hibernate on the other hand interprets all eager access to use join. No point debating which is better - they are situational and there are good reasons to go with either solution as a generic one.

This means that if you want a join with EclipseLink on the fly, you'll have to do more than just indicate the relationship needs to be eagerly fetched, and include in query hints. If you are going with fetch graphs to optimize things, it might be a helpful to look into the other fetch types, such as batch fetching. An extra query/statement isn't always a bad thing for performance, especially as object graphs grow. The database is going to be forced to return N*M duplicate rows of Foo data, one for each Bar and FooBar combination in the results. Depending on the data size, there will be a point where it is more efficient to get the children in separate queries.

You can use EntityGraphJpaSpecificationExecutor to pass different entitygraph based on your method.

as far as I know, entity graphs define which attributes to fetch from the database so you can fetch the 2 attributes eagerly and the other 3 lazily, "Thorben Janssen" has a good article on his website about graphs, another way to exclusively fetch selected attributes is to use DTO Projections, he also does have a good article touching the subject.

The regular fix for solving MultipleBagFetchException is change List typed fields on Set typed, like this:

That's a known issue and I think Hibernate 6.0 will fix it, but I don't remember if there ever was a ticket for this.

This could be an issue with the id class support or your use of @JoinFormula. Try using embeddable ids instead:

This will be the case with @OneToOne mapping. I have been there, done that. To get past through that you would have to implement bytecode enhancement on Hibernate dirty checking mechanism and change parent side not to use proxy (annotation : @LazyToOne(LazyToOneOption.NO_PROXY)).

Please refer to Vlad Mihalcea's article describing exactly your case I think

In that article you will also find a link to anothere useful Vlad's article - an information how to implement the bytecode enhancement