Mit Beziehungen arbeiten

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

RelationQueryBuilder ist eine spezielle Art von QueryBuilder, die dir ermöglicht, mit deinen Relationen zu arbeiten. Damit kannst du Entitäten in der Datenbank miteinander verknüpfen, ohne Entitäten laden zu müssen, oder verknüpfte Entitäten einfach laden.

Angenommen, wir haben eine Post-Entität mit einer Many-to-Many-Beziehung zu Category namens categories. Fügen wir eine neue Kategorie zu dieser Many-to-Many-Beziehung hinzu:

await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post)
    .add(category)

Dieser Code entspricht folgendem Vorgehen:

const postRepository = dataSource.manager.getRepository(Post)
const post = await postRepository.findOne({
    where: {
        id: 1,
    },
    relations: {
        categories: true,
    },
})
post.categories.push(category)
await postRepository.save(post)

Aber er ist effizienter, da er minimal viele Operationen ausführt und Entitäten direkt in der Datenbank verknüpft, anstatt einen umständlichen save-Methodenaufruf durchzuführen.

Ein weiterer Vorteil dieses Ansatzes ist, dass du nicht alle verknüpften Entitäten laden musst, bevor du etwas hinzufügst. Wenn du beispielsweise zehntausend Kategorien in einem Post hast, wird das Hinzufügen neuer Kategorien problematisch, da der Standardweg wäre, den Post mit allen zehntausend Kategorien zu laden, eine neue Kategorie hinzuzufügen und zu speichern. Das führt zu erheblichen Performance-Einbußen und ist in Produktionsumgebungen praktisch unbrauchbar. RelationQueryBuilder löst dieses Problem.

Außerdem brauchst du keine vollständigen Entitäten zum "Verknüpfen" - du kannst stattdessen Entitäts-IDs verwenden. Fügen wir beispielsweise eine Kategorie mit ID = 3 zu einem Post mit ID = 1 hinzu:

await dataSource.createQueryBuilder().relation(Post, "categories").of(1).add(3)

Bei zusammengesetzten Primärschlüsseln musst du sie als ID-Map übergeben, zum Beispiel:

await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of({ firstPostId: 1, secondPostId: 3 })
    .add({ firstCategoryId: 2, secondCategoryId: 4 })

Entitäten kannst du genauso entfernen wie hinzufügen:

// this code removes a category from a given post
await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .remove(category) // you can use just category id as well

Das Hinzufügen und Entfernen funktioniert bei many-to-many- und one-to-many-Beziehungen. Für one-to-one- und many-to-one-Beziehungen verwende stattdessen set:

// this code sets category of a given post
await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .set(category) // you can use just category id as well

Um eine Beziehung aufzuheben (auf null zu setzen), übergibst du einfach null an die set-Methode:

// this code unsets category of a given post
await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .set(null)

Neben dem Aktualisieren von Beziehungen ermöglicht dir der Relation Query Builder auch, verknüpfte Entitäten zu laden. Angenommen, eine Post-Entität hat eine Many-to-Many-Beziehung categories und eine Many-to-One-Beziehung user, dann kannst du diese Beziehungen mit folgendem Code laden:

const post = await dataSource.manager.findOneBy(Post, {
    id: 1,
})

post.categories = await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .loadMany()

post.author = await dataSource
    .createQueryBuilder()
    .relation(Post, "user")
    .of(post) // you can use just post id as well
    .loadOne()