Spring Data Einträge von User zahlen und auflisten

[lam_tr]

Hallo zusammen,

ich habe zwei Entities:

class User{
@Id
@GeneratedValue
private Long id;
private String name;
// Getter / setter
}

class Eintraege{
@Id
@GeneratedValue
private Long id;

@OneToOne(cascadeType=CascadeType.All)
private User user;
// Getter / setter
}

Die zwei DB Tabellen werden aktuell auch befüllt. Meine Frage ist jetzt wie kann ich im Spring Data den folgenden Statement erstellen?

Select u.name, count(e.*) from User u inner join Eintraege e on u.id  = e.user.id

Im Endeffekt soll das Ergebnis so aussehen

Name Anzahl Eintraege
----------------------------------------
Müller 10
Kraus 22
Punda 41
Karm 6
Jean 1

Muss ich da ein neue Klasse für das Ergebnis erstellen, der die Anzahl er Einträge mit Namen zwischenspeichert?
Oder mache ich da eine Datenbank View? Wie wird das dann von Spring Data abegrufen?

Viele Grüße
lam

 

[lam_tr]

Sorry statement ist nicht vollständig

Select u.name, count(e.*) from User u inner join Eintraege e on u.id  = e.user.id group by u.name

 

[mrBrown]

Das ist doch eine OneToOne-Beziehung, also immer ein Eintrag pro Nutzer?

 

[lam_tr]

Stimmt, das Model ist veraltet, Danke!

Ich habe es mittlerweile mit einer Custom Query in die Repository klasse realisiert.

 

[looparda]

Kannst du deine Lösung hier schreiben? Ich hatte mir das Problem nachgebaut und auch etwas mit Projection probiert, war jedoch nicht ganz erfolgreich. Außerdem war mir unklar ob du es nun in einen eigenen Datentypen mappen willst oder als Map<String, Long>.

 

[lam_tr]

Kannst du deine Lösung hier schreiben? Ich hatte mir das Problem nachgebaut und auch etwas mit Projection probiert, war jedoch nicht ganz erfolgreich. Außerdem war mir unklar ob du es nun in einen eigenen Datentypen mappen willst oder als Map<String, Long>.

Morgen looparda,

vielen Dank für die Mühe.

Ich habe mir ein neuer Interface dafür angelegt "UserRanking" mit getName und getCount.

Im InterfaceRepository Klasse habe ich dann um die Methode erweitert.

@Query(value="
Select u.name, count(e.*) from User u inner join Eintraege e on u.id  = e.user.id group by u.name")
List<UserRanking> countEntraegeByUser();

Ich habe das unegfähr so gemacht, den Code habe ich leider zu Hause.

Viele Grüße
lam

 

[looparda]

Ok, also hast du es auch über eine Projection gelöst. Mein letzter Stand war:

@Repository
public interface EntraegeRepository extends JpaRepository<Eintraege, Long> {

    @Query("Select u.name as UserName, count(e.id) as Count from User u inner join Eintraege e on u.id  = e.user.id group by u.name")
    List<EintraegeProjection> countUserEintraege();

    interface EintraegeProjection {
        String getUserName();
        int getCount();
    }
}

@ExtendWith(SpringExtension.class)
@SpringBootTest
class EntraegeRepositoryTest {

    @Autowired
    EntraegeRepository entraegeRepository;

    @BeforeEach
    void setUp() {
        final Eintraege eintraege = new Eintraege();
        final User a = new User("a");
        eintraege.setUser(a);
        entraegeRepository.save(eintraege);

        final Eintraege eintraege2 = new Eintraege();
        final User b = new User("b");
        eintraege2.setUser(b);
        entraegeRepository.save(eintraege2);
    }

    @Test
    void testCountUserEintraege() {
        final List<EntraegeRepository.EintraegeProjection> eintraegeProjections = entraegeRepository.countUserEintraege();
        assertThat(eintraegeProjections).isNotEmpty();
        assertThat(eintraegeProjections.get(0).getUserName()).isEqualTo("a");
    }
}

aber leider lieferten die Aufrufe immer null. Siehst du auf Anhieb den entscheidenden Unterschied?

 

[lam_tr]

Auf den ersten Blick sieht es nicht viel anders aus wie mein Code. Merkwürdig.