Join fetch returns duplicate results

Hello,

Join fetch on a Repository returns duplicate entities depending on the number of records in the one to many association

Example project here - https://github.com/kirans9731/repo-join-fetch.git

@Entity
@Table(name = "customer")
public class Customer {

    private Long id;
    private String name;
    private String email;
    private String address;

    private Set<Order> orders = new HashSet<>();

    ....

    @OneToMany (mappedBy = "customer", cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
    public Set<Order> getOrders() {
        return orders;
    }
}

@Entity
@Table(name = "orders")
public class Order {

    private Long id;
    private String product;

    private Customer customer;

    ....
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    public Customer getCustomer() {
        return customer;
    }
}

@Repository
public interface CustomerRepository extends CrudRepository<Customer, Long> {

    @Join(value = "orders", type = Join.Type.FETCH)
    Collection<Customer> findByName(String name);
}

@MicronautTest
public class CustomerRepositoryTest {

    @Inject
    CustomerRepository customerRepository;

    @BeforeEach
    public void init() {

        Customer customer = new Customer();
        customer.setName("Kiran");
        customer.setAddress("USA");
        customer.setEmail("[e-mail]");

        Order order1 = new Order();
        order1.setCustomer(customer);
        order1.setProduct("Prod1");

        Order order2 = new Order();
        order2.setCustomer(customer);
        order2.setProduct("Prod2");

        Order order3 = new Order();
        order3.setCustomer(customer);
        order3.setProduct("Prod1");

        customer.getOrders().add(order1);
        customer.getOrders().add(order2);
        customer.getOrders().add(order3);

        customerRepository.save(customer);
    }

    @Test
    public void test_findByName() {

        Collection<Customer> customers = customerRepository.findByName("Kiran");
        Assertions.assertEquals(1, customers.size()); // this is 3
    }
}
    

[graemerocher]

@psoares I agree we need to make this easier, but altering the behaviour of @Join(..) is not the correct thing to do and will create more confusion since for me @Join(..) by its name indicates you want to perform a join query (INNER JOIN, LEFT JOIN etc.)

My current plan is to add an additional annotation probably named @Select(..) that will allow you to give a hint to Micronaut Data to perform an additional select to retrieve the association as well in cases where you need it.

[psoares]

@graemerocher Although your explanation makes perfect sense, I think either micronaut-data should handle the initialization of collection properties in a simpler manner, or the docs should have more examples of how to handle different situations. From the docs, I find it hard to understand that the @Join annotation can be used in a @ManyToOne or @OneToOne relationships, but not in a @OneToMany.