TypeORM - Relacje

Relacje służą do odwoływania się do relacji między tabelami w bazie danych. Ogólnie rzecz biorąc, relacja istnieje między dwiema tabelami, gdy jedna z nich ma klucz obcy, który odwołuje się do klucza podstawowego drugiej tabeli. Ta funkcja sprawia, że relacyjna baza danych jest bardziej wydajna i wydajniejsza do przechowywania informacji.

TypeORM umożliwia powiązanie jednostek ze sobą, a następnie tabelami bazy danych. Ogólnie rzecz biorąc, relacje można podzielić na cztery szersze kategorie. Są one następujące:

one-to-one- Jeden przedmiot danego podmiotu dotyczy tylko jednego przedmiotu podmiotu docelowego i odwrotnie. Na przykład, kraj będzie miał tylko jedną stolicę i podobnie miasto będzie stolicą tylko jednego kraju.

many-to-one- Wiele obiektów danego podmiotu dotyczy jednego obiektu podmiotu docelowego. Na przykład miasto należy tylko do jednego kraju, ale kraj może mieć wiele miast.

one-to-many - To samo, co wiele do jednego, z tą różnicą, że relacja jest odwrócona.

many-to-many- Wielokrotny przedmiot danego podmiotu dotyczy wielu obiektów podmiotu docelowego. Na przykład artykuł może być oznaczony w wielu tematach, takich jak język programowania, finanse itp., A jednocześnie określony tag może zawierać wiele artykułów.

TypeORM zapewnia również opcje ulepszania relacji między podmiotami. Są następujące -

eager - Obiekt jednostki źródłowej ładuje również obiekty jednostki docelowej.
cascade - Obiekt encji docelowej zostaje wstawiony lub zaktualizowany podczas wstawiania lub aktualizowania obiektu encji źródłowej.
onDelete - Obiekty encji docelowej są również usuwane, podczas gdy obiekt encji źródłowej jest usuwany.
primary - Służy do określania, czy kolumna relacji jest kluczem podstawowym, czy nie.
nullable - Służy do określania, czy kolumna relacji ma wartość null, czy nie.

Przyjrzyjmy się szczegółowo różnym typom mapowania relacji.

Jeden na jednego

Jak dowiedzieliśmy się wcześniej, odwołuje się do niego wystąpienie jednego pola tabeli, które zawiera wystąpienie innego pola tabeli i odwrotnie. Stwórzmy plikDetails stół -

Details.ts

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity() 
export class Details {
   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   gender: string; 
   
   @Column() 
   country: string; 
}

Stwórzmy kolejny podmiot Klient w następujący sposób -

Customer.ts

import {Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn} from "typeorm"; 

import {Details} from "./Details"; 

@Entity() 
export class Customer { 

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string; 
   
   @OneToOne(type => Details) @JoinColumn() 
   details: Details;
}

Tutaj,

Dodaliśmy mapowanie OneToOne do Details stół. @JoinColumn() zawierają „identyfikator relacji” i klucz obcy do Customerstół. Możemy zapisać relację w formacieindex.ts w następujący sposób -

const details = new Details(); details.gender = "female"; details.country = "india" await connection.manager.save(details);

const customer = new Customer(); customer.name = 'customer1'; customer.details = Details; await connection.manager.save(Customer);

Jeden do wielu i wiele do jednego

Jak dowiedzieliśmy się wcześniej, odwołuje się do niego wystąpienie pierwszego pola tabeli, które zawiera wiele wystąpień drugiego pola tabeli o nazwie One-to-Many mapowanie i wiele wystąpień pierwszej tabeli zawiera tylko jedno wystąpienie drugiej tabeli o nazwie Many-to-One mapowanie.

Rozważmy przykład Student i project podmioty, podczas gdy student może pracować nad więcej niż jednym projektem, ale każdy projekt jest obsługiwany tylko przez jednego ucznia.

Stwórzmy plik Project podmiot w następujący sposób -

Projekt

import {Entity, PrimaryGeneratedColumn, Column, ManyToOne} from "typeorm"; import {Student} from "./Student"; 
@Entity() 
export class Project {  

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   projects: string; 
   
   @ManyToOne(type => Student, student => student.projects) student: Student; 
}

Teraz tworzymy Student podmiot jak poniżej -

import {Entity, PrimaryGeneratedColumn, Column, OneToMany} from "typeorm"; import {Project} from "./Project"; 

@Entity() 
export class User {  
   
   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string; 
   
   @OneToMany(type => Project, project => project.student) projects: Project[];  
}

Tutaj,

@OneToMany zmapowana właściwość Project i @ManyToOne przypisana właściwość Student. Jednak,@OneToMany nie może istnieć bez @ManyToOne i @ManyToOne właściwość zawiera „identyfikator relacji” i klucz obcy.

Możemy zapisać połączenie w formacie index.ts w następujący sposób -

const proj1 = new Project(); proj1.projects = "database management"; await connection.manager.save(proj1); 

const proj2 = new Project(); proj2.projects = "web application"; await connection.manager.save(proj2); 

const stud = new Student(); stud.name = "Student1"; stud.projects = [proj1, proj2]; await connection.manager.save(stud);

Wiele do wielu

Jak dowiedzieliśmy się wcześniej, wiele rekordów w jednej tabeli jest powiązanych z wieloma rekordami w innej tabeli. Rozważmy przykład: student uniwersytetu może być zapisany na wiele zajęć jednocześnie, co oznacza, że student może mieć cztery lub pięć zajęć w semestrze, a klasa może mieć wielu studentów.

Możemy po prostu stwierdzić, że uczeń ma wiele zajęć, a klasa ma wielu uczniów. Stwórzmy jednostkę dlaClasses w następujący sposób -

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm"; 

@Entity() 
export class Classes { 

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string; 
}

Teraz tworzymy Student podmiot jak poniżej -

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

@Entity() 
export class Student { 

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   name: string;

   @Column() 
   subjects: string; 
   
   @ManyToMany(type => Classes) @JoinTable() 
   classes: Classes[];
}