This behaviour is actually correct.
The real problem is that a Specification is really a (leaky) abstraction over a WHERE-clause.
By using fetch and distinct you are not only affecting the WHERE-clause though, but also the projection, i.e. the SELECT clause.
This leads to confusion and ultimately errors.

The problem with a JOIN FETCH is, it isn't really a join. From.getJoins() doesn't return it, which makes sense, since it must not be referenced anywhere in the rest of the statement.
From the Java Persistence API, Version 2.2 Section 4.4.5.3 Fetch Joins

A FETCH JOIN enables the fetching of an association or element collection as a side effect of the exe- cution of a query.
The syntax for a fetch join is
fetch_join ::= [ LEFT [OUTER] | INNER ] JOIN FETCH join_association_path_expression (emphasis is mine)
The association referenced by the right side of the FETCH JOIN clause must be an association or element collection that is referenced from an entity or embeddable that is returned as a result of the query. It is not permitted to specify an identification variable for the objects referenced by the right side of the FETCH JOIN clause, and hence references to the implicitly fetched entities or elements cannot appear elsewhere in the query.

This talks about JPQL but I think it is save to assume the equivalent holds true for the Criteria-API used by a Specification.

This means the fetch-join must not and can not be used in a WHERE-clause or ORDER-BY-clause.
Therefore Spring Data JPA has to create an additional JOIN for that purpose.

This of course clashes on the SQL level with the DISTINCT since it basically ignores the additional JOIN and therefore it can't be used in the ORDER-BY-clause.

There is a good Stack Overflow answer regarding this topic.

@schauder considering the entities described in this issue, if I create a specification

Specification<A> specification =
(root, query, builder) -> {
   query.distinct(true); 
   root.fetch(A_.b, JoinType.LEFT);
   return builder.equal(root.get(A_.b).get(B_.name), “smth”)

};

aRepository.findAll(specification);

please note the equal predicate

then

List<T> findAll(Specification<T> spec);

then creates SQL

select distinct A1.id, A1.b_id, B1.id, B1.name
from A A1
   left join B B1 on A1.b_id = B1.id
where B1.name = "smth"

fetch-join is used in the WHERE clause. No additional join is created.

based on your statement

This means the fetch-join must not and can not be used in a WHERE-clause or ORDER-BY-clause.
Therefore Spring Data JDBC has to create an additional JOIN for that purpose.

Are you sayin that observed behaviour is a bug and additional join should have been created?

Are you sayin that observed behaviour is a bug and additional join should have been created?

According to my understanding of the specification this is indeed wrong behaviour.
It results in an A being loaded without the B.
I might compromise on "inconsistent behaviour" since if the join is reused by a predicate it should be returned by From.getJoins().

I reopen the issue.
I still think it is not us to fix it, but we should create a proper JPA based reproducer so we can ask the JPA maintainers and implementors for their opinion.

Thanks for the issue.
This would help us a lot currently 🙏

+1
trying to use distinct with join fetch and order by a field in the join but the order by is wrong it that it isn't the table that was fetched but instead a duplicate join that's not in the select
Here is what is produced

select distinct c1_0.c_id,
a1_0.stat_cd,
a1_0.stat_desc,
a1_0.seq_no,
c1_0.stat_cd,
c1_0.c_attr,
from a.ctable c1_0
   left join a.astat a1_0 on a1_0.stat_cd=c1_0.stat_cd
   left join a.astat a2_0 on a2_0.stat_cd=c1_0.stat_cd
order by a2_0.seq_no offset 0 rows fetch first 10 rows only;

but i want

select distinct c1_0.c_id,
a1_0.stat_cd,
a1_0.stat_desc,
a1_0.seq_no,
c1_0.stat_cd,
c1_0.c_attr,
from a.ctable c1_0
   left join a.astat a1_0 on a1_0.stat_cd=c1_0.stat_cd
order by a1_0.seq_no offset 0 rows fetch first 10 rows only;

+1 trying to use distinct with join fetch and order by a field in the join but the order by is wrong it that it isn't the table that was fetched but instead a duplicate join that's not in the select Here is what is produced

select distinct c1_0.c_id,
a1_0.stat_cd,
a1_0.stat_desc,
a1_0.seq_no,
c1_0.stat_cd,
c1_0.c_attr,
from a.ctable c1_0
   left join a.astat a1_0 on a1_0.stat_cd=c1_0.stat_cd
   left join a.astat a2_0 on a2_0.stat_cd=c1_0.stat_cd
order by a2_0.seq_no offset 0 rows fetch first 10 rows only;

but i want

select distinct c1_0.c_id,
a1_0.stat_cd,
a1_0.stat_desc,
a1_0.seq_no,
c1_0.stat_cd,
c1_0.c_attr,
from a.ctable c1_0
   left join a.astat a1_0 on a1_0.stat_cd=c1_0.stat_cd
order by a1_0.seq_no offset 0 rows fetch first 10 rows only;

Did you find any solution to this?

+1 trying to use distinct with join fetch and order by a field in the join but the order by is wrong it that it isn't the table that was fetched but instead a duplicate join that's not in the select Here is what is produced

select distinct c1_0.c_id,
a1_0.stat_cd,
a1_0.stat_desc,
a1_0.seq_no,
c1_0.stat_cd,
c1_0.c_attr,
from a.ctable c1_0
   left join a.astat a1_0 on a1_0.stat_cd=c1_0.stat_cd
   left join a.astat a2_0 on a2_0.stat_cd=c1_0.stat_cd
order by a2_0.seq_no offset 0 rows fetch first 10 rows only;

but i want

select distinct c1_0.c_id,
a1_0.stat_cd,
a1_0.stat_desc,
a1_0.seq_no,
c1_0.stat_cd,
c1_0.c_attr,
from a.ctable c1_0
   left join a.astat a1_0 on a1_0.stat_cd=c1_0.stat_cd
order by a1_0.seq_no offset 0 rows fetch first 10 rows only;

Did you find any solution to this?

I had to right my own specification for this whole thing and override my Spring JPA repository handling of the query
without much context, here is the method i wrote

public static <T> Specification<T> distinctFetchJoinOrder(String fetchAttribute, String joinAttribute, Pageable pageable) {
        return (root, query, criteriaBuilder) -> {
            query.distinct(true);
            var join = (Join<?, ?>) root.fetch(fetchAttribute, JoinType.LEFT);
            List<Order> orders = new ArrayList<>();
            orders.add(criteriaBuilder.asc(join.get(joinAttribute)));
            pageable.getSort().stream().map(order -> {
                if (order.isAscending()) {
                    return criteriaBuilder.asc(root.get(order.getProperty()));
                } else {
                    return criteriaBuilder.desc(root.get(order.getProperty()));
                }
            }).forEach(orders::add);
            query.orderBy(orders);
            return null;
        };
    }

I suspect my issue is related to this ticket:
basically I got error when using JOIN FETCH in specifications for a paginated result.
Exactly like in this post
https://stackoverflow.com/questions/61637545/how-to-solve-the-n1-problem-in-spring-data-jpa
It fails to issue the count query with

"org.hibernate.query.SemanticException: Query specified join fetching, but the owner of the fetched association was not present in the select list [SqmSingularJoin(it.tredi.area.udo_service.udo.Udo(53).udoType(54) : udoType)]"

Is there any sane solution to get around this problem? It sounds quite basic to me, and I find strange it even shows up (maybe I'm doing something wrong?)
Wouldn't keeping out the fetch for count query as suggested in that SO bring to wrong count if the joined entities are used for some filtering?
This is my simple spec that fails when used for a paginated findAll from JpaSimpleRepository

public Specification<Udo> withMainPaths(Boolean isDisabled) {
    return (root, query, cb) -> {
      root.fetch(Udo_.UDO_TYPE, JoinType.LEFT);
      query.distinct(true);
      return isDisabled(isDisabled).toPredicate(root, query, cb);
    };
  }