Eager- und Lazy-Relations

Inoffizielle Beta-Übersetzung

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

Eager-Relations

Eager-Relations werden automatisch geladen, wenn du Entitäten aus der Datenbank abrufst. Beispiel:

import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from "typeorm"
import { Question } from "./Question"

@Entity()
export class Category {
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    name: string

    @ManyToMany((type) => Question, (question) => question.categories)
    questions: Question[]
}

import {
    Entity,
    PrimaryGeneratedColumn,
    Column,
    ManyToMany,
    JoinTable,
} from "typeorm"
import { Category } from "./Category"

@Entity()
export class Question {
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    title: string

    @Column()
    text: string

    @ManyToMany((type) => Category, (category) => category.questions, {
        eager: true,
    })
    @JoinTable()
    categories: Category[]
}

Beim Laden von Fragen musst du keine Joins angeben oder Relationen explizit laden. Sie werden automatisch geladen:

const questionRepository = dataSource.getRepository(Question)

// questions will be loaded with its categories
const questions = await questionRepository.find()

Eager-Relations funktionieren nur mit find*-Methoden. Bei Verwendung von QueryBuilder sind Eager-Relations deaktiviert – hier musst du leftJoinAndSelect verwenden. Eager-Relations können nur auf einer Seite der Beziehung verwendet werden. Die Verwendung von eager: true auf beiden Seiten ist nicht erlaubt.

Lazy-Relations

Entitäten in Lazy-Relations werden erst geladen, wenn du darauf zugreifst. Solche Relationen müssen den Typ Promise haben – der Wert wird in einem Promise gespeichert, und beim Laden wird ebenfalls ein Promise zurückgegeben. Beispiel:

import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from "typeorm"
import { Question } from "./Question"

@Entity()
export class Category {
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    name: string

    @ManyToMany((type) => Question, (question) => question.categories)
    questions: Promise<Question[]>
}

import {
    Entity,
    PrimaryGeneratedColumn,
    Column,
    ManyToMany,
    JoinTable,
} from "typeorm"
import { Category } from "./Category"

@Entity()
export class Question {
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    title: string

    @Column()
    text: string

    @ManyToMany((type) => Category, (category) => category.questions)
    @JoinTable()
    categories: Promise<Category[]>
}

categories ist ein Promise. Das bedeutet, es handelt sich um eine Lazy-Relation, die nur ein Promise mit einem Wert speichern kann. Beispiel zum Speichern solcher Relationen:

const category1 = new Category()
category1.name = "animals"
await dataSource.manager.save(category1)

const category2 = new Category()
category2.name = "zoo"
await dataSource.manager.save(category2)

const question = new Question()
question.categories = Promise.resolve([category1, category2])
await dataSource.manager.save(question)

Beispiel zum Laden von Objekten in Lazy-Relations:

const [question] = await dataSource.getRepository(Question).find()
const categories = await question.categories
// you'll have all question's categories inside "categories" variable now

Hinweis: Falls du aus anderen Sprachen (Java, PHP etc.) kommst und überall Lazy-Relations gewohnt bist – sei vorsichtig. Diese Sprachen sind nicht asynchron, und Lazy Loading wird anders implementiert, ohne Promises. In JavaScript und Node.JS musst du Promises verwenden, wenn du Lazy-Relations benötigst. Dies ist eine nicht standardisierte Technik und in TypeORM als experimentell eingestuft.