TypeORM - Relazioni

Le relazioni vengono utilizzate per fare riferimento alla relazione tra la tabella nel database. In generale, esiste una relazione tra due tabelle quando una di esse ha una chiave esterna che fa riferimento alla chiave primaria dell'altra tabella. Questa funzionalità rende il database relazionale più potente e archivia le informazioni in modo efficiente.

TypeORM consente alle entità di essere correlate tra loro e successivamente tabelle di database. In generale, la relazione può essere classificata in quattro categorie più ampie. Sono i seguenti,

one-to-one- Un oggetto dell'entità data si riferisce a un solo oggetto dell'entità target e viceversa. Ad esempio, un paese avrà solo una capitale e allo stesso modo una città sarà capitale di un solo paese.

many-to-one- Più oggetti dell'entità data si riferiscono a un oggetto dell'entità target. Ad esempio, la città rientra in un solo paese ma il paese può avere più città.

one-to-many - Uguale a molti-a-uno tranne per il fatto che la relazione è invertita.

many-to-many- Più oggetti dell'entità data si riferiscono a più oggetti dell'entità di destinazione. Ad esempio, un articolo può essere taggato sotto più argomenti come linguaggio di programmazione, finanza, ecc. E allo stesso tempo un tag particolare può avere anche più articoli.

TypeORM fornisce anche opzioni per migliorare la relazione tra le entità. Sono i seguenti:

eager - L'oggetto entità di origine carica anche gli oggetti entità di destinazione.
cascade - L'oggetto entità di destinazione viene inserito o aggiornato mentre l'oggetto entità di origine viene inserito o aggiornato.
onDelete - Anche gli oggetti entità di destinazione vengono eliminati mentre viene eliminato l'oggetto entità di origine.
primary - Utilizzato per specificare che la colonna della relazione è o meno la chiave primaria.
nullable - Utilizzato per specificare che la colonna della relazione è annullabile o meno.

Esaminiamo in dettaglio diversi tipi di mappatura delle relazioni.

Uno a uno

Come abbiamo appreso in precedenza, viene indicato dall'istanza di un campo di tabella contenente l'istanza di un altro campo di tabella e viceversa. Creiamo un fileDetails tavolo -

Details.ts

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

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

Creiamo un'altra entità Cliente come segue:

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;
}

Qui,

Abbiamo aggiunto la mappatura OneToOne per Details tavolo. @JoinColumn() contenere un "id relazione" e una chiave esterna per Customertavolo. Possiamo salvare la relazione inindex.ts come segue -

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);

Uno-a-molti e molti-a-uno

Come abbiamo appreso in precedenza, viene indicato dall'istanza del primo campo della tabella che contiene più istanze del secondo campo della tabella chiamato One-to-Many mapping e più istanze della prima tabella contiene solo un'istanza della seconda tabella chiamata Many-to-One Mappatura.

Considera un esempio di Student e project entità mentre lo studente può lavorare su più di un progetto ma ogni progetto è gestito da un solo studente.

Creiamo un file Project entità come segue -

Progetto

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; 
}

Ora creiamo Student entità come di seguito -

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[];  
}

Qui,

@OneToMany proprietà mappata Project e @ManyToOne proprietà mappata a Student. Però,@OneToMany non può esistere senza @ManyToOne e @ManyToOne la proprietà contiene "id relazione" e chiave esterna.

Possiamo salvare la connessione in index.ts come segue -

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);

Molti a molti

Come abbiamo appreso in precedenza, viene indicato da più record in una tabella che sono correlati a più record in un'altra tabella. Considera un esempio, uno studente universitario può essere iscritto a più classi contemporaneamente, il che significa che lo studente può avere quattro o cinque classi per semestre e una classe può avere molti studenti.

Possiamo semplicemente concludere, uno studente ha molte classi e una classe ha molti studenti. Creiamo un'entità perClasses come segue -

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

@Entity() 
export class Classes { 

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